# Complete cogs command reference

The complete command and argument declarations from the cogs CLI, with flags and defaults.

Source: https://docs.minds.sh/docs/developers/reference/cli



The declarations below are extracted from the CLI parser. CamelCase names become kebab-case commands unless an explicit `name` attribute overrides them. `#[arg(long)]` denotes a long flag, `Option` denotes an optional value, and `Vec` denotes repeated values. This is command availability in source, not a guarantee that every backing service is enabled or every handler is implemented.

Start with the [CLI guide](/docs/developers/cli) for installation, connections, and common tasks.

## Cli [#cli]

```rust
struct Cli {
    /// Path to config TOML/YAML/JSON; falls back to ./akasha-cli.toml and AKASHA__* env vars
    #[arg(short, long)]
    config: Option<PathBuf>,
    /// Override base URL
    #[arg(long)]
    base_url: Option<String>,
    /// Override auth token env var name (token read from this env)
    #[arg(long)]
    token_env: Option<String>,
    /// Skip launching the Control Room TUI (legacy behavior for automation)
    #[arg(long)]
    no_tui: bool,
    #[command(subcommand)]
    command: Option<Commands>,
}
```

Source: `minds-cli/src/main.rs:101`.

## Commands [#commands]

```rust
enum Commands {
    /// Storage and namespace operations
    Storage(StorageCmd),
    /// Graph operations
    Graph(GraphCmd),
    /// Analytics operations
    Analytics(AnalyticsCmd),
    /// ML operations
    Ml(MlCmd),
    /// Memory operations
    Memory(MemoryCmd),
    /// Associative Memory (MHN)
    AssocMhn(AssocMhnCmd),
    /// Cognitive logging
    Cognitive(CognitiveCmd),
    /// Cognitive Cycle orchestration
    Cycle(CycleCmd),
    /// Continual
    Continual(ContinualCmd),
    /// SNN
    Snn(SnnCmd),
    /// Neuro-Symbolic
    Ns(NsCmd),
    /// Raw HTTP passthrough
    Http(HttpCmd),
    /// Router operations via Knowledge Router gRPC
    Router(RouterCmd),
    /// Conductor orchestration over gRPC
    Conductor(ConductorCmd),
    /// OCIP capability invocation over gRPC transport
    Ocip(OcipCmd),
    /// Replication link management
    Replication(ReplicationCmd),
    /// Interchange bundle workflows
    Interchange(InterchangeCmd),
    /// Interactive REPL
    Repl {
        #[arg(long)]
        cmd: Option<String>,
    },
    /// Startup assistant and daemon launcher
    Start,
    /// Manage saved instances
    Instances(InstancesCmd),
    /// Control Room TUI
    #[command(name = "control-room")]
    ControlRoom,
    /// Settings TUI
    Settings,
    /// Interactive Neurosymbolic Pipeline Builder
    BuildPipeline {
        #[arg(long)]
        tui: bool,
        #[arg(long)]
        out: Option<std::path::PathBuf>,
    },
    /// Real-Time Model Introspection TUI
    Introspect {
        #[arg(long)]
        model_id: Option<String>,
        #[arg(long, default_value_t = false)]
        snn: bool,
        #[arg(long)]
        refresh_ms: Option<u64>,
    },
    /// Automated Ablation Studies
    Ablate {
        #[arg(long)]
        dataset: String,
        #[arg(long)]
        base_req: String,
        #[arg(long)]
        params: String,
        #[arg(long, default_value_t = 1)]
        runs: usize,
        #[arg(long)]
        concurrency: Option<usize>,
        #[arg(long)]
        out_md: Option<std::path::PathBuf>,
        #[arg(long)]
        dp_epsilon: Option<f64>,
        #[arg(long, default_value_t = false)]
        tui: bool,
    },
    /// AI-Assisted Query & Viz Builder
    Query {
        #[arg(long)]
        natural: Option<String>,
        #[arg(long, default_value_t = true)]
        tui: bool,
    },
    /// Experiment Reproducibility Suite
    Repro(ReproCmd),
    /// Privacy-preserving federated training
    Federate(FederateCmd),
    /// Diagnostics and maintenance
    Diagnostics(DiagnosticsCmd),
    /// Resolve an akasha:// URI to its base URL
    Resolve { uri: String },
    /// Generate synthetic data via cognitive augmentation rules
    Augment {
        #[arg(long)]
        rules: PathBuf,
        #[arg(long)]
        output: PathBuf,
        #[arg(long, default_value_t = 1000)]
        size: usize,
    },
    /// Run AutoML sweeps on a dataset within a resource budget
    Automl {
        #[arg(long)]
        dataset: PathBuf,
        #[arg(long)]
        budget: Option<String>,
        #[arg(long, default_value_t = false)]
        tui: bool,
    },
    /// Fuse symbolic rules with neural model outputs
    Fuse {
        #[arg(long)]
        symbolic: PathBuf,
        #[arg(long)]
        neural: PathBuf,
        #[arg(long, default_value_t = false)]
        tui: bool,
    },
    /// Primitive pipeline management
    Primitives(PrimitivesCmd),
    /// Cloud service management
    Services(ServicesCmd),
    /// Authenticate with Akasha Cloud
    Login {
        #[arg(long)]
        api_key: Option<String>,
        #[arg(long)]
        org_id: Option<String>,
        #[arg(long, default_value = "https://api.akasha.l1fe.ai")]
        base_url: String,
    },
    /// Logout from Akasha Cloud
    Logout,
    /// Local service orchestration
    Local(LocalCmd),
    /// MCP (Model Context Protocol) server management
    Mcp(McpCmd),
}
```

Source: `minds-cli/src/main.rs:119`.

## StorageCmd [#storagecmd]

```rust
struct StorageCmd {
    #[command(subcommand)]
    action: StorageAction,
}
```

Source: `minds-cli/src/main.rs:267`.

## StorageAction [#storageaction]

```rust
enum StorageAction {
    Keyspaces,
    CreateKeyspace {
        name: String,
        model: String,
    },
    Stats,
    #[command(name = "import-domain-primitives")]
    ImportDomainPrimitives {
        keyspace: String,
        #[arg(long, alias = "path")]
        file: PathBuf,
        #[arg(long)]
        schema_version: Option<u32>,
        #[arg(long, default_value_t = false)]
        upsert: bool,
    },
    #[command(name = "export-domain-primitives")]
    ExportDomainPrimitives {
        keyspace: String,
        #[arg(long)]
        schema_version: Option<u32>,
        #[arg(long)]
        out: Option<PathBuf>,
    },
    #[command(name = "create-backup")]
    CreateBackup {
        backup_dir: PathBuf,
        #[arg(long)]
        compression_level: Option<u32>,
        #[arg(long)]
        disable_compression: bool,
        #[arg(long, default_value_t = true)]
        include_wal: bool,
        #[arg(long)]
        rate_limit: Option<u64>,
        #[arg(long)]
        remote_fs_dir: Option<PathBuf>,
        #[arg(long)]
        remote_s3_bucket: Option<String>,
        #[arg(long)]
        remote_s3_prefix: Option<String>,
        #[arg(long)]
        remote_s3_region: Option<String>,
        #[arg(long)]
        remote_s3_profile: Option<String>,
        #[arg(long)]
        remote_s3_storage_class: Option<String>,
    },
    #[command(name = "list-backups")]
    ListBackups {
        backup_dir: PathBuf,
    },
    #[command(name = "delete-backup")]
    DeleteBackup {
        backup_dir: PathBuf,
        backup_id: String,
    },
    #[command(name = "restore-backup")]
    RestoreBackup {
        backup_dir: PathBuf,
        backup_id: String,
        #[arg(long, default_value_t = true)]
        verify_checksums: bool,
        #[arg(long, default_value_t = false)]
        skip_corrupted: bool,
    },
    #[command(name = "kv-health")]
    KvHealth,
    #[command(name = "kv-consistency")]
    KvConsistency,
    #[command(subcommand, name = "volumes")]
    Volumes(#[command(subcommand)] VolumeAction),
}
```

Source: `minds-cli/src/main.rs:273`.

## VolumeAction [#volumeaction]

```rust
enum VolumeAction {
    List,
    Create(VolumeCreateArgs),
    Attach(VolumeAttachArgs),
    Detach { volume_id: String },
    Delete { volume_id: String },
}
```

Source: `minds-cli/src/main.rs:350`.

## VolumeKind [#volumekind]

```rust
enum VolumeKind {
    S3,
    Filesystem,
}
```

Source: `minds-cli/src/main.rs:401`.

## PrimitivesCmd [#primitivescmd]

```rust
struct PrimitivesCmd {
    #[command(subcommand)]
    action: PrimitivesAction,
}
```

Source: `minds-cli/src/main.rs:423`.

## PrimitivesAction [#primitivesaction]

```rust
enum PrimitivesAction {
    Generate {
        domain: String,
        #[arg(long, default_value_t = 1200)]
        count: usize,
        #[arg(long)]
        out: PathBuf,
        #[arg(long, default_value = "python")]
        python: String,
        #[arg(long, default_value = "tools/primitive-pipeline/pipeline.py")]
        script: PathBuf,
        #[arg(long, default_value = "automated_pipeline")]
        source: String,
        #[arg(long, default_value = "AKASHA Primitive Agent")]
        author: String,
        #[arg(long)]
        references: Vec<String>,
    },
    Validate {
        #[arg(long)]
        input: PathBuf,
        #[arg(long)]
        report: Option<PathBuf>,
        #[arg(long, default_value = "python")]
        python: String,
        #[arg(long, default_value = "tools/primitive-pipeline/pipeline.py")]
        script: PathBuf,
    },
    Import {
        #[arg(long)]
        input: PathBuf,
        #[arg(long)]
        keyspace: Option<String>,
        #[arg(long)]
        reservoir: Option<String>,
        #[arg(long)]
        dataspace: Option<String>,
        #[arg(long, default_value_t = false)]
        dry_run: bool,
        #[arg(long)]
        schema_version: Option<u32>,
        #[arg(long, default_value_t = false)]
        upsert: bool,
    },
}
```

Source: `minds-cli/src/main.rs:429`.

## ServicesCmd [#servicescmd]

```rust
struct ServicesCmd {
    #[command(subcommand)]
    action: ServicesAction,
}
```

Source: `minds-cli/src/main.rs:476`.

## ServicesAction [#servicesaction]

```rust
enum ServicesAction {
    /// List all services
    Ls {
        #[arg(long)]
        org_id: Option<String>,
    },
    /// Create a new service
    Create {
        #[arg(long)]
        service_type: String,
        #[arg(long)]
        plan: String,
        #[arg(long)]
        name: String,
    },
    /// Get service details
    Get { service_id: String },
    /// Delete a service
    Delete {
        service_id: String,
        #[arg(long)]
        force: bool,
    },
}
```

Source: `minds-cli/src/main.rs:482`.

## LocalCmd [#localcmd]

```rust
struct LocalCmd {
    #[command(subcommand)]
    action: LocalAction,
}
```

Source: `minds-cli/src/main.rs:508`.

## LocalAction [#localaction]

```rust
enum LocalAction {
    /// Start local AkashaKV
    Kv,
    /// Start local AkashaGraph
    Graph,
    /// Start all local services
    Start,
    /// Stop all local services
    Stop,
    /// Check status of local services
    Status,
    /// View logs of local services
    Logs {
        #[arg(long)]
        service: Option<String>,
    },
}
```

Source: `minds-cli/src/main.rs:514`.

## McpCmd [#mcpcmd]

```rust
struct McpCmd {
    #[command(subcommand)]
    action: McpAction,
}
```

Source: `minds-cli/src/main.rs:533`.

## McpAction [#mcpaction]

```rust
enum McpAction {
    /// Auto-configure Claude Desktop to use Akasha MCP server
    #[command(name = "setup-claude")]
    SetupClaude {
        /// Path to the akasha-mcp binary (defaults to "akasha-mcp")
        #[arg(long)]
        binary: Option<String>,
        /// Akasha daemon endpoint URL forwarded as --endpoint
        #[arg(long)]
        endpoint: Option<String>,
    },
    /// Auto-configure Cursor editor to use Akasha MCP server
    #[command(name = "setup-cursor")]
    SetupCursor {
        /// Path to the akasha-mcp binary (defaults to "akasha-mcp")
        #[arg(long)]
        binary: Option<String>,
        /// Akasha daemon endpoint URL forwarded as --endpoint
        #[arg(long)]
        endpoint: Option<String>,
    },
    /// Thin alias: forward to the `akasha-mcp` binary (top-level flags)
    Serve {
        /// Path to the akasha-mcp binary (defaults to "akasha-mcp")
        #[arg(long)]
        binary: Option<String>,
        /// Transport type forwarded as --transport (default: stdio)
        #[arg(long)]
        transport: Option<String>,
        /// Akasha daemon endpoint URL forwarded as --endpoint
        #[arg(long)]
        endpoint: Option<String>,
        /// API key forwarded as --api-key
        #[arg(long)]
        api_key: Option<String>,
        /// Namespace forwarded as --namespace
        #[arg(long)]
        namespace: Option<String>,
        /// Agent id forwarded as --agent-id
        #[arg(long)]
        agent_id: Option<String>,
    },
    /// Quick-test an MCP tool with JSON arguments
    Test {
        /// Tool name (e.g. "remember", "recall", "forget")
        tool: String,
        /// JSON arguments for the tool
        arguments: String,
        /// Namespace to test against
        #[arg(long)]
        namespace: Option<String>,
    },
    /// Show MCP server info (version, tools, tiers)
    Info,
    /// List all available MCP tools with details
    Tools,
}
```

Source: `minds-cli/src/main.rs:539`.

## GraphCmd [#graphcmd]

```rust
struct GraphCmd {
    #[command(subcommand)]
    action: GraphAction,
}
```

Source: `minds-cli/src/main.rs:598`.

## GraphAction [#graphaction]

```rust
enum GraphAction {
    Cypher {
        query: String,
    },
    #[command(name = "subdomain-query")]
    SubdomainQuery {
        namespace: String,
        domain: String,
        subdomain: String,
        #[arg(short, long, default_value_t = 50)]
        limit: usize,
    },
    EnsureIndex {
        property: String,
    },
    Fulltext {
        query: String,
        #[arg(short, long, default_value_t = 10)]
        limit: usize,
    },
    Pagerank {
        #[arg(long)]
        damping: Option<f64>,
    },
    ShortestPath {
        source: String,
        target: String,
    },
    Components {
        #[arg(long, default_value_t = false)]
        strong: bool,
    },
    MicrotheorySwitch {
        name: String,
    },
    MicrotheoryKeyspace {
        name: String,
    },
}
```

Source: `minds-cli/src/main.rs:604`.

## AnalyticsCmd [#analyticscmd]

```rust
struct AnalyticsCmd {
    #[command(subcommand)]
    action: AnalyticsAction,
}
```

Source: `minds-cli/src/main.rs:645`.

## AnalyticsAction [#analyticsaction]

```rust
enum AnalyticsAction {
    Sql { query: String },
    RegisterCsv { name: String, path: String },
    RegisterParquet { name: String, path: String },
    Options { options: String },
    CacheClear,
    CacheStats,
}
```

Source: `minds-cli/src/main.rs:651`.

## MlCmd [#mlcmd]

```rust
struct MlCmd {
    #[command(subcommand)]
    action: MlAction,
}
```

Source: `minds-cli/src/main.rs:661`.

## MlAction [#mlaction]

```rust
enum MlAction {
    Models,
    Generate {
        model_id: String,
        prompt: String,
        #[arg(long, default_value_t = 256)]
        max_tokens: usize,
        #[arg(long, default_value_t = 0.8)]
        temperature: f32,
        #[arg(long)]
        stream: bool,
    },
    Embed {
        text: Vec<String>,
    },
    Load {
        name: String,
        #[arg(long)]
        model_type: String,
        #[arg(long)]
        framework: String,
        #[arg(long)]
        url: String,
    },
    Unload {
        model_id: String,
    },
    VectorCreate {
        name: String,
        dims: usize,
        metric: String,
    },
    VectorAdd {
        name: String,
        id: String,
        embedding: Vec<f32>,
    },
    VectorSearch {
        name: String,
        query: Vec<f32>,
        k: usize,
    },
    VectorSave {
        name: String,
    },
    VectorList,
    Metrics {
        #[arg(long)]
        model_id: Option<String>,
    },
    Browse,
}
```

Source: `minds-cli/src/main.rs:667`.

## MemoryCmd [#memorycmd]

```rust
struct MemoryCmd {
    #[command(subcommand)]
    action: MemoryAction,
}
```

Source: `minds-cli/src/main.rs:721`.

## MemoryAction [#memoryaction]

```rust
enum MemoryAction {
    Search {
        query: String,
        #[arg(short, long, default_value_t = 10)]
        limit: usize,
    },
    EpisodicStore {
        raw_from: String,
        #[arg(long)]
        tag: Vec<String>,
    },
    RetrievalHybrid {
        text: String,
        #[arg(long)]
        limit: Option<usize>,
    },
}
```

Source: `minds-cli/src/main.rs:727`.

## AssocMhnCmd [#assocmhncmd]

```rust
struct AssocMhnCmd {
    #[command(subcommand)]
    action: AssocMhnAction,
}
```

Source: `minds-cli/src/main.rs:746`.

## AssocMhnAction [#assocmhnaction]

```rust
enum AssocMhnAction {
    New {
        dimensions: usize,
    },
    Store {
        id: String,
        vector: Vec<f32>,
    },
    RetrieveByKey {
        id: String,
    },
    RetrieveByVector {
        vector: Vec<f32>,
        #[arg(long, default_value_t = 1)]
        k: usize,
    },
    Clear,
    Stats,
    Config,
    SystemInfo,
}
```

Source: `minds-cli/src/main.rs:752`.

## CognitiveCmd [#cognitivecmd]

```rust
struct CognitiveCmd {
    #[command(subcommand)]
    action: CognitiveAction,
}
```

Source: `minds-cli/src/main.rs:775`.

## CognitiveAction [#cognitiveaction]

```rust
enum CognitiveAction {
    Thought { json: String },
    Decision { json: String },
    Interaction { json: String },
    Session { json: String },
    SessionUpdate { json: String },
    Query { json: String },
    DecisionTrace { id: String },
}
```

Source: `minds-cli/src/main.rs:781`.

## CycleCmd [#cyclecmd]

```rust
struct CycleCmd {
    #[command(subcommand)]
    action: CycleAction,
}
```

Source: `minds-cli/src/main.rs:792`.

## CycleAction [#cycleaction]

```rust
enum CycleAction {
    Start,
    Stop,
    Metrics,
    Reinforce {
        trace_id: String,
        value: f32,
        #[arg(long)]
        source: Option<String>,
    },
    Experience {
        content: String,
        #[arg(long)]
        context: Option<String>,
    },
}
```

Source: `minds-cli/src/main.rs:798`.

## ContinualCmd [#continualcmd]

```rust
struct ContinualCmd {
    #[command(subcommand)]
    action: ContinualAction,
}
```

Source: `minds-cli/src/main.rs:816`.

## ContinualAction [#continualaction]

```rust
enum ContinualAction {
    Checkpoints { req: String },
    CheckpointsStatus,
    Recover { req: String },
    Components { req: String },
    DeleteComponent { id: String },
}
```

Source: `minds-cli/src/main.rs:822`.

## SnnCmd [#snncmd]

```rust
struct SnnCmd {
    #[command(subcommand)]
    action: SnnAction,
}
```

Source: `minds-cli/src/main.rs:831`.

## SnnAction [#snnaction]

```rust
enum SnnAction {
    NetworkBuild {
        req: String,
    },
    NetworkCompile {
        req: String,
    },
    NetworkStep {
        req: String,
    },
    TrainBptt {
        req: String,
        #[arg(long)]
        dp_epsilon: Option<f64>,
    },
    NetworkState,
}
```

Source: `minds-cli/src/main.rs:837`.

## NsCmd [#nscmd]

```rust
struct NsCmd {
    #[command(subcommand)]
    action: NsAction,
}
```

Source: `minds-cli/src/main.rs:856`.

## NsAction [#nsaction]

```rust
enum NsAction {
    Retrieve { req: String },
    RetrieveWithMode { req: String },
    PathsFind { req: String },
    PrefetchStart { req: String },
    PrefetchStop { req: String },
    CacheStats,
    CbExecute { name: String, req: String },
}
```

Source: `minds-cli/src/main.rs:862`.

## HttpCmd [#httpcmd]

```rust
struct HttpCmd {
    #[command(subcommand)]
    action: HttpAction,
}
```

Source: `minds-cli/src/main.rs:873`.

## HttpAction [#httpaction]

```rust
enum HttpAction {
    Get { path: String },
    Post { path: String, body: String },
    Put { path: String, body: String },
    Delete { path: String },
}
```

Source: `minds-cli/src/main.rs:879`.

## RouterCmd [#routercmd]

```rust
struct RouterCmd {
    #[command(subcommand)]
    action: RouterAction,
}
```

Source: `minds-cli/src/main.rs:887`.

## RouterAction [#routeraction]

```rust
enum RouterAction {
    Start {
        #[arg(long, default_value = "http://127.0.0.1:50051")]
        endpoint: String,
        #[arg(long, default_value = "127.0.0.1:50051")]
        bind: String,
        #[arg(long, default_value_t = 100)]
        max_results: u32,
        #[arg(long, default_value_t = 0.1)]
        trust_threshold: f64,
        #[arg(long, default_value_t = false)]
        metrics: bool,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Register {
        #[arg(long, default_value = "http://127.0.0.1:50051")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
        #[arg(long)]
        dataspace_id: String,
        #[arg(long)]
        agent_id: String,
        #[arg(long)]
        host: String,
        #[arg(long)]
        query_endpoint: String,
        #[arg(long)]
        capabilities: Vec<String>,
        #[arg(long)]
        specializations: Vec<String>,
        #[arg(long, default_value = "public")]
        visibility: String,
    },
    Route {
        #[arg(long, default_value = "http://127.0.0.1:50051")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
        #[arg(long)]
        from: String,
        #[arg(long)]
        to: Option<String>,
        #[arg(long, default_value_t = false)]
        test: bool,
    },
    Trust {
        #[arg(long, default_value = "http://127.0.0.1:50051")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
        #[arg(long, default_value_t = false)]
        mtls: bool,
        #[arg(long)]
        cert: Option<PathBuf>,
        #[arg(long)]
        key: Option<PathBuf>,
        #[arg(long)]
        ca_cert: Option<PathBuf>,
    },
    Info {
        #[arg(long, default_value = "http://127.0.0.1:50051")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
        #[arg(long, default_value_t = false)]
        health: bool,
        #[arg(long, default_value_t = false)]
        backends: bool,
    },
}
```

Source: `minds-cli/src/main.rs:893`.

## ConductorCmd [#conductorcmd]

```rust
struct ConductorCmd {
    #[command(subcommand)]
    action: ConductorAction,
}
```

Source: `minds-cli/src/main.rs:967`.

## ConductorAction [#conductoraction]

```rust
enum ConductorAction {
    Init {
        #[arg(long)]
        pipeline: PathBuf,
        #[arg(long)]
        name: Option<String>,
        #[arg(long, default_value_t = false)]
        default: bool,
        #[arg(long, default_value = "http://127.0.0.1:8082")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Ingest {
        #[arg(long)]
        source: String,
        #[arg(long)]
        schema: Option<PathBuf>,
        #[arg(long, default_value_t = false)]
        mtls: bool,
        #[arg(long, default_value = "http://127.0.0.1:8082")]
        endpoint: String,
        #[arg(long, default_value = "json")]
        format: String,
        #[arg(long, default_value_t = 100)]
        batch_size: usize,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Metrics {
        #[arg(long, default_value = "prometheus")]
        export: String,
        #[arg(long)]
        output: Option<PathBuf>,
        #[arg(long, default_value = "http://127.0.0.1:8082")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Replay {
        #[arg(long)]
        from: String,
        #[arg(long)]
        to: String,
        #[arg(long, default_value = "http://127.0.0.1:8082")]
        endpoint: String,
        #[arg(long, default_value = "json")]
        format: String,
        #[arg(long, default_value_t = 1000)]
        limit: usize,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Info {
        #[arg(long, default_value = "http://127.0.0.1:8082")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
        #[arg(long, default_value_t = false)]
        pipelines: bool,
        #[arg(long, default_value_t = false)]
        status: bool,
    },
}
```

Source: `minds-cli/src/main.rs:973`.

## OcipCmd [#ocipcmd]

```rust
struct OcipCmd {
    #[command(subcommand)]
    action: OcipAction,
}
```

Source: `minds-cli/src/main.rs:1039`.

## OcipAction [#ocipaction]

```rust
enum OcipAction {
    Invoke {
        #[arg(long)]
        cap: String,
        #[arg(long)]
        payload: String,
        #[arg(long, default_value = "http://127.0.0.1:8080")]
        endpoint: String,
        #[arg(long)]
        actor: Option<String>,
        #[arg(long)]
        tenant: Option<String>,
        #[arg(long)]
        idempotency_key: Option<String>,
        #[arg(long, default_value_t = 30)]
        timeout: u64,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Preflight {
        #[arg(long)]
        cap: String,
        #[arg(long, default_value = "http://127.0.0.1:8080")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        dry_run: bool,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Retry {
        #[arg(long)]
        correlation_id: String,
        #[arg(long, default_value_t = 3)]
        max_attempts: u32,
        #[arg(long, default_value = "http://127.0.0.1:8080")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Limits {
        #[arg(long)]
        rate: String,
        #[arg(long, default_value_t = 100)]
        burst: u32,
        #[arg(long)]
        ip: Option<String>,
        #[arg(long)]
        tenant: Option<String>,
        #[arg(long, default_value = "http://127.0.0.1:8080")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Discover {
        #[arg(long, default_value = "http://127.0.0.1:8080")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        detailed: bool,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Validate {
        #[arg(long)]
        schema: String,
        #[arg(long)]
        payload: String,
        #[arg(long, default_value = "https://registry.l1fe.ai/schemas")]
        registry: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
}
```

Source: `minds-cli/src/main.rs:1045`.

## ReplicationCmd [#replicationcmd]

```rust
struct ReplicationCmd {
    #[command(subcommand)]
    action: ReplicationAction,
}
```

Source: `minds-cli/src/main.rs:1119`.

## ReplicationAction [#replicationaction]

```rust
enum ReplicationAction {
    Start {
        #[arg(long)]
        source: String,
        #[arg(long)]
        destination: String,
        #[arg(long)]
        link_id: Option<String>,
        #[arg(long)]
        keyspaces: Vec<String>,
        #[arg(long)]
        poll_ms: Option<u64>,
        #[arg(long)]
        batch_size: Option<usize>,
        #[arg(long, default_value = "http://127.0.0.1:7080")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
}
```

Source: `minds-cli/src/main.rs:1125`.

## InterchangeCmd [#interchangecmd]

```rust
struct InterchangeCmd {
    #[command(subcommand)]
    action: InterchangeAction,
}
```

Source: `minds-cli/src/main.rs:1147`.

## InterchangeAction [#interchangeaction]

```rust
enum InterchangeAction {
    Export {
        #[arg(long)]
        out: PathBuf,
        #[arg(long)]
        keyspaces: Vec<String>,
        #[arg(long)]
        destination_tag: Option<String>,
        #[arg(long)]
        redact_fields: Vec<String>,
        #[arg(long)]
        key_hex: Option<String>,
        #[arg(long, default_value = "http://127.0.0.1:7081")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
    Import {
        #[arg(long)]
        bundle: PathBuf,
        #[arg(long)]
        allowed_destination_tags: Vec<String>,
        #[arg(long)]
        transform_redact_fields: Vec<String>,
        #[arg(long)]
        key_hex: Option<String>,
        #[arg(long, default_value = "http://127.0.0.1:7081")]
        endpoint: String,
        #[arg(long, default_value_t = false)]
        tls: bool,
    },
}
```

Source: `minds-cli/src/main.rs:1153`.

## InstancesCmd [#instancescmd]

```rust
struct InstancesCmd {
    #[command(subcommand)]
    action: InstancesAction,
}
```

Source: `minds-cli/src/main.rs:1187`.

## InstancesAction [#instancesaction]

```rust
enum InstancesAction {
    List,
    Add,
    Remove { name: String },
    Use { name: String },
    Show,
    Sync,
}
```

Source: `minds-cli/src/main.rs:1193`.

## DiagnosticsCmd [#diagnosticscmd]

```rust
struct DiagnosticsCmd {
    #[command(subcommand)]
    action: DiagnosticsAction,
}
```

Source: `minds-cli/src/main.rs:1203`.

## DiagnosticsAction [#diagnosticsaction]

```rust
enum DiagnosticsAction {
    /// Detect and optionally remove stale Tantivy lock files
    TantivyLocks {
        /// Root data directory to scan (defaults to Akasha default data dir)
        #[arg(long)]
        data_dir: Option<String>,
        /// Specific graph keyspace to scan (otherwise scan all)
        #[arg(long)]
        graph_keyspace: Option<String>,
        /// Remove detected lock files
        #[arg(long)]
        clean: bool,
        /// Proceed with cleaning even if a daemon appears healthy
        #[arg(long)]
        force: bool,
    },
}
```

Source: `minds-cli/src/main.rs:1209`.

## ReproCmd [#reprocmd]

```rust
struct ReproCmd {
    #[command(subcommand)]
    action: ReproAction,
}
```

Source: `minds-cli/src/main.rs:1228`.

## ReproAction [#reproaction]

```rust
enum ReproAction {
    Capture {
        file: String,
        #[arg(long)]
        cmd: Option<String>,
    },
    Run {
        file: String,
    },
    Diff {
        a: String,
        b: String,
        #[arg(long, default_value_t = 1e-6)]
        tol: f64,
        #[arg(long, default_value_t = false)]
        tui: bool,
    },
}
```

Source: `minds-cli/src/main.rs:1234`.

## FederateCmd [#federatecmd]

```rust
struct FederateCmd {
    /// Number of simulated client nodes
    #[arg(long, value_parser = ValueParser::new(|s: &str| parse_bounded_usize::<1, 1024>(s)))]
    nodes: usize,
    /// Path to dataset shard or directory
    #[arg(long)]
    dataset: String,
    /// Number of global rounds
    #[arg(long, value_parser = ValueParser::new(|s: &str| parse_bounded_usize::<1, 100000>(s)))]
    rounds: usize,
    /// Enable TUI
    #[arg(long, default_value_t = false)]
    tui: bool,
    /// Override DP epsilon (<= global config epsilon)
    #[arg(long)]
    dp_epsilon: Option<f64>,
    /// Concurrent clients per round (default: min(nodes, max_threads))
    #[arg(long)]
    concurrency: Option<usize>,
}
```

Source: `minds-cli/src/main.rs:1264`.