# Operations

Every registered operations instance operation, with source-derived inputs, outputs, access policy, and errors.

Source: https://docs.minds.sh/docs/api/instance/operations



This reference covers **12 HTTP operations** registered by the Akasha daemon. Call these paths on your instance base URL. See [authentication](/docs/api/instance/authentication), [errors](/docs/api/instance/errors), and [coverage](/docs/api/instance/coverage) before integrating.

| Method | Path                      | Operation                                          |
| ------ | ------------------------- | -------------------------------------------------- |
| `GET`  | `/health/live`            | [Health live](#get-health-live)                    |
| `GET`  | `/health/ready`           | [Health ready](#get-health-ready)                  |
| `GET`  | `/health/startup`         | [Health startup](#get-health-startup)              |
| `GET`  | `/v1/health/live`         | [Health live](#get-v1-health-live)                 |
| `GET`  | `/v1/health/ready`        | [Health ready](#get-v1-health-ready)               |
| `GET`  | `/v1/health/startup`      | [Health startup](#get-v1-health-startup)           |
| `GET`  | `/v1/kv/health`           | [Kv health](#get-v1-kv-health)                     |
| `GET`  | `/metrics`                | [Metrics](#get-metrics)                            |
| `GET`  | `/v1/system/info`         | [System info](#get-v1-system-info)                 |
| `GET`  | `/v1/lifecycle/status`    | [Lifecycle status](#get-v1-lifecycle-status)       |
| `GET`  | `/v1/health/all`          | [Health all](#get-v1-health-all)                   |
| `GET`  | `/v1/conductor/endpoints` | [Conductor endpoints](#get-v1-conductor-endpoints) |

<a id="get-health-live" />

## GET `/health/live` [#get-healthlive]

Health live

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response]

**Declared return:** `impl IntoResponse`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
HealthResponse { status: "ok" }
```

### Errors and validation [#errors-and-validation]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_live() -> impl IntoResponse {
        Json(HealthResponse { status: "ok" })
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:2187`. Registration: `akasha-daemon/src/main.rs:4342`.

<a id="get-health-ready" />

## GET `/health/ready` [#get-healthready]

Health ready

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-1]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-1]

**Declared return:** `impl IntoResponse`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
HealthResponse { status }
```

### Errors and validation [#errors-and-validation-1]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_ready(State(state): State<AppState>) -> impl IntoResponse {
        let ok = state
            .db
            .as_ref()
            .map(|db| db.list_keyspaces().is_ok())
            .unwrap_or(false);
        let status = if ok { "ok" } else { "degraded" };
        Json(HealthResponse { status })
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:2190`. Registration: `akasha-daemon/src/main.rs:4343`.

<a id="get-health-startup" />

## GET `/health/startup` [#get-healthstartup]

Health startup

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-2]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-2]

**Declared return:** `Result<Json<serde_json::Value>, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({
        "status": "ok",
        "services": services
    })
```

### Errors and validation [#errors-and-validation-2]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_startup(
        State(state): State<AppState>,
    ) -> Result<Json<serde_json::Value>, DaemonError> {
        state.record_http_request();
        let start = std::time::Instant::now();
        let mut services = {
            let runtime = state.service_runtime.read().await;
            runtime
                .entries()
                .map(|(_, entry)| entry.clone())
                .collect::<Vec<_>>()
        };
        for entry in &mut services {
            overlay_live_subsystem_state(&state, entry);
        }
        state
            .metrics
            .observe_health_latency("startup", start.elapsed());
        Ok(Json(serde_json::json!({
            "status": "ok",
            "services": services
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10317`. Registration: `akasha-daemon/src/main.rs:4344`.

<a id="get-v1-health-live" />

## GET `/v1/health/live` [#get-v1healthlive]

Health live

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-3]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-3]

**Declared return:** `impl IntoResponse`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
HealthResponse { status: "ok" }
```

### Errors and validation [#errors-and-validation-3]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_live() -> impl IntoResponse {
        Json(HealthResponse { status: "ok" })
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:2187`. Registration: `akasha-daemon/src/main.rs:4345`.

<a id="get-v1-health-ready" />

## GET `/v1/health/ready` [#get-v1healthready]

Health ready

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-4]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-4]

**Declared return:** `impl IntoResponse`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
HealthResponse { status }
```

### Errors and validation [#errors-and-validation-4]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_ready(State(state): State<AppState>) -> impl IntoResponse {
        let ok = state
            .db
            .as_ref()
            .map(|db| db.list_keyspaces().is_ok())
            .unwrap_or(false);
        let status = if ok { "ok" } else { "degraded" };
        Json(HealthResponse { status })
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:2190`. Registration: `akasha-daemon/src/main.rs:4346`.

<a id="get-v1-health-startup" />

## GET `/v1/health/startup` [#get-v1healthstartup]

Health startup

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-5]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-5]

**Declared return:** `Result<Json<serde_json::Value>, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({
        "status": "ok",
        "services": services
    })
```

### Errors and validation [#errors-and-validation-5]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_startup(
        State(state): State<AppState>,
    ) -> Result<Json<serde_json::Value>, DaemonError> {
        state.record_http_request();
        let start = std::time::Instant::now();
        let mut services = {
            let runtime = state.service_runtime.read().await;
            runtime
                .entries()
                .map(|(_, entry)| entry.clone())
                .collect::<Vec<_>>()
        };
        for entry in &mut services {
            overlay_live_subsystem_state(&state, entry);
        }
        state
            .metrics
            .observe_health_latency("startup", start.elapsed());
        Ok(Json(serde_json::json!({
            "status": "ok",
            "services": services
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10317`. Registration: `akasha-daemon/src/main.rs:4347`.

<a id="get-v1-kv-health" />

## GET `/v1/kv/health` [#get-v1kvhealth]

Kv health

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-6]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-6]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
report
```

### Errors and validation [#errors-and-validation-6]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn kv_health(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        state.ensure_runtime_service_enabled("kv").await?;
        let start = std::time::Instant::now();
        let report = db.akashakv().health_report();
        state.metrics.observe_health_latency("kv", start.elapsed());
        Ok(Json(report))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:3277`. Registration: `akasha-daemon/src/main.rs:4348`.

<a id="get-metrics" />

## GET `/metrics` [#get-metrics]

Metrics

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-7]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-7]

**Declared return:** `Response`

Serialization is delegated or the handler returns a raw response. Consult the exact handler below; the OpenAPI response intentionally remains unconstrained.

### Errors and validation [#errors-and-validation-7]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

Explicit status constants: `INTERNAL_SERVER_ERROR`.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn metrics(state: State<AppState>) -> Response {
        let snap = state.cognitive_cycle_metrics.snapshot();
        state.metrics.sync_cognitive_cycle_metrics(&snap);
        let mut buffer = Vec::new();
        let encoder = TextEncoder::new();
        if let Err(e) = encoder.encode(&state.metrics.registry.gather(), &mut buffer) {
            error!(error = %e, "encode metrics");
            return StatusCode::INTERNAL_SERVER_ERROR.into_response();
        }
        let mut resp = Response::new(axum::body::Body::from(buffer));
        resp.headers_mut().insert(
            axum::http::header::CONTENT_TYPE,
            HeaderValue::from_static("text/plain; version=0.0.4"),
        );
        resp
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:2170`. Registration: `akasha-daemon/src/main.rs:4350`.

<a id="get-v1-system-info" />

## GET `/v1/system/info` [#get-v1systeminfo]

System info

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-8]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-8]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({
        "version": env!("CARGO_PKG_VERSION"),
        "uptime": uptime_secs,
        "build": "release"
    })
```

### Errors and validation [#errors-and-validation-8]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn system_info(State(state): State<AppState>) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let uptime_secs = state.start_time.elapsed().as_secs();
        Ok(Json(serde_json::json!({
            "version": env!("CARGO_PKG_VERSION"),
            "uptime": uptime_secs,
            "build": "release"
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10425`. Registration: `akasha-daemon/src/main.rs:4358`.

<a id="get-v1-lifecycle-status" />

## GET `/v1/lifecycle/status` [#get-v1lifecyclestatus]

Lifecycle status

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-9]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-9]

**Declared return:** `impl IntoResponse`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
state.lifecycle.status()
```

### Errors and validation [#errors-and-validation-9]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn lifecycle_status(State(state): State<AppState>) -> impl IntoResponse {
        Json(state.lifecycle.status())
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:2200`. Registration: `akasha-daemon/src/main.rs:4359`.

<a id="get-v1-health-all" />

## GET `/v1/health/all` [#get-v1healthall]

Health all

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Global credential bypass. Configured HTTPS enforcement still applies.

### Request [#request-10]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-10]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({
        "status": status,
        "checks": checks,
        "latencyMs": latency_ms,
        "timestamp": chrono::Utc::now().to_rfc3339()
    })
```

### Errors and validation [#errors-and-validation-10]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn health_all(State(state): State<AppState>) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let start = std::time::Instant::now();
        let runtime = state.service_runtime.read().await;
        let mut checks: Vec<serde_json::Value> = Vec::new();
        let mut all_pass = true;

        let services_to_check = [
            "kv",
            "graph",
            "analytics",
            "memory",
            "snn",
            "mhn",
            "continual",
            "mcp",
            "inference",
        ];
        for svc in &services_to_check {
            if let Some(entry) = runtime.entry(svc) {
                let pass = entry.enabled && entry.status == RuntimeServiceStatus::Running;
                if !pass {
                    all_pass = false;
                }
                checks.push(serde_json::json!({
                    "name": svc,
                    "status": if pass { "pass" } else { "fail" },
                    "message": entry.message.clone().unwrap_or_default()
                }));
            }
        }
        drop(runtime);

        let latency_ms = start.elapsed().as_millis();
        let status = if all_pass { "healthy" } else { "degraded" };
        Ok(Json(serde_json::json!({
            "status": status,
            "checks": checks,
            "latencyMs": latency_ms,
            "timestamp": chrono::Utc::now().to_rfc3339()
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10436`. Registration: `akasha-daemon/src/main.rs:4360`.

<a id="get-v1-conductor-endpoints" />

## GET `/v1/conductor/endpoints` [#get-v1conductorendpoints]

Conductor endpoints

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered`                                              |
| Runtime service      | No prefix-level service check; handler dependencies still apply. |
| Handler dependencies | See handler source and return expressions.                       |

**Access:** Daemon authentication and capability namespace authority; memory-domain permissions apply where mapped.

### Request [#request-11]

No typed JSON, query, or path extractor is declared in the handler signature. Headers or request objects may still be consumed; the signature below is authoritative.

### Response [#response-11]

**Declared return:** `Result<impl IntoResponse, DaemonError>`

The following are the exact JSON construction expressions in the handler. Values such as `rows`, `result`, and delegated types are runtime values, not literal example payloads.

```rust
serde_json::json!({"endpoints": paths, "total": paths.len()}),
```

### Errors and validation [#errors-and-validation-11]

Directly referenced error variants: none in the handler body. Middleware and delegated services can return additional errors described in the shared error reference.

<Accordions>
  <Accordion title="Inspect implementation">
    This exact source excerpt includes validation, defaults, delegated calls, and response assembly.

    ```rust
    async fn conductor_endpoints(
        State(state): State<AppState>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let config = &state.service_config;
        let mut paths: Vec<String> = Vec::new();

        // Always available
        paths.extend_from_slice(&[
            "/health/live".to_string(),
            "/health/ready".to_string(),
            "/health/startup".to_string(),
            "/v1/health/live".to_string(),
            "/v1/health/ready".to_string(),
            "/v1/health/startup".to_string(),
            "/v1/health/all".to_string(),
            "/v1/system/info".to_string(),
            "/v1/kv/health".to_string(),
            "/v1/kv/consistency".to_string(),
            "/v1/cognitive/health".to_string(),
            "/v1/conductor/endpoints".to_string(),
            "/metrics".to_string(),
        ]);

        if config.enable_analytics {
            paths.extend_from_slice(&[
                "/v1/analytics/sql".to_string(),
                "/v1/analytics/views".to_string(),
                "/v1/analytics/health".to_string(),
            ]);
        }
        if config.enable_graph {
            paths.extend_from_slice(&[
                "/v1/graph/cypher".to_string(),
                "/v1/graph/alg/pagerank".to_string(),
                "/v1/graph/health".to_string(),
            ]);
        }
        if config.enable_snn {
            paths.extend_from_slice(&[
                "/v1/snn/network/build".to_string(),
                "/v1/snn/stats".to_string(),
                "/v1/snn/health".to_string(),
            ]);
        }
        if config.enable_mhn {
            paths.extend_from_slice(&[
                "/v1/assoc/mhn/new".to_string(),
                "/v1/assoc/mhn/list".to_string(),
                "/v1/mhn/health".to_string(),
            ]);
        }
        if config.enable_memory {
            paths.extend_from_slice(&[
                "/v1/memory/episodic".to_string(),
                "/v1/memory/stats".to_string(),
                "/v1/memory/vault/access-log".to_string(),
                "/v1/memory/resources/chunks".to_string(),
                "/v1/memory/health".to_string(),
            ]);
        }
        if config.enable_mcp {
            paths.extend_from_slice(&[
                "/v1/mcp/tools/list".to_string(),
                "/v1/mcp/tools/call".to_string(),
                "/v1/mcp/connection".to_string(),
                "/v1/mcp/stats".to_string(),
                "/v1/mcp/history".to_string(),
                "/v1/mcp/health".to_string(),
            ]);
        }
        if config.enable_continual {
            paths.extend_from_slice(&[
                "/v1/continual/task/pause".to_string(),
                "/v1/continual/task/resume".to_string(),
                "/v1/continual/config".to_string(),
                "/v1/continual/health".to_string(),
            ]);
        }
        if config.enable_neurosymbolic {
            paths.extend_from_slice(&[
                "/v1/ns/retrieve".to_string(),
                "/v1/ns/history".to_string(),
                "/v1/ns/rules".to_string(),
                "/v1/ns/stats".to_string(),
            ]);
        }

        paths.push("/v1/cognitive/cycles".to_string());
        paths.push("/v1/cognitive/config".to_string());
        paths.push("/v1/cognitive/stats".to_string());
        paths.push("/v1/working-memory/slots".to_string());
        paths.push("/v1/working-memory/config".to_string());
        paths.push("/v1/working-memory/stats".to_string());

        Ok(Json(
            serde_json::json!({"endpoints": paths, "total": paths.len()}),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11302`. Registration: `akasha-daemon/src/main.rs:4361`.