Complete cogs command reference

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>,
}

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),
}

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

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),
}

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

enum VolumeKind {
    S3,
    Filesystem,
}

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

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,
    },
}

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

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,
    },
}

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

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>,
    },
}

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

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,
}

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

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,
    },
}

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

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

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

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,
}

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

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>,
    },
}

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

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,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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,
    },
}

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

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,
    },
}

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

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,
    },
}

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

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,
    },
}

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

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,
    },
}

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

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

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

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,
    },
}

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

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,
    },
}

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>,
}