# Continual Learning

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

Source: https://docs.minds.sh/docs/api/instance/continual-learning



This reference covers **15 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`  | `/v1/continual/checkpoints/status` | [Continual checkpoint status](#get-v1-continual-checkpoints-status)    |
| `POST` | `/v1/continual/recover`            | [Continual recover](#post-v1-continual-recover)                        |
| `POST` | `/v1/continual/components`         | [Continual component register](#post-v1-continual-components)          |
| `POST` | `/v1/continual/components/delete`  | [Continual component unregister](#post-v1-continual-components-delete) |
| `POST` | `/v1/continual/task/new`           | [Continual task new](#post-v1-continual-task-new)                      |
| `POST` | `/v1/continual/task/train`         | [Continual task train](#post-v1-continual-task-train)                  |
| `POST` | `/v1/continual/task/stats`         | [Continual task stats](#post-v1-continual-task-stats)                  |
| `POST` | `/v1/continual/task/evaluate`      | [Continual task evaluate](#post-v1-continual-task-evaluate)            |
| `POST` | `/v1/continual/task/delete`        | [Continual task delete](#post-v1-continual-task-delete)                |
| `POST` | `/v1/continual/task/consolidate`   | [Continual task consolidate](#post-v1-continual-task-consolidate)      |
| `GET`  | `/v1/continual/health`             | [Continual health](#get-v1-continual-health)                           |
| `POST` | `/v1/continual/task/pause`         | [Continual task pause](#post-v1-continual-task-pause)                  |
| `POST` | `/v1/continual/task/resume`        | [Continual task resume](#post-v1-continual-task-resume)                |
| `GET`  | `/v1/continual/config`             | [Continual config get](#get-v1-continual-config)                       |
| `PUT`  | `/v1/continual/config`             | [Continual config update](#put-v1-continual-config)                    |

<a id="get-v1-continual-checkpoints-status" />

## GET `/v1/continual/checkpoints/status` [#get-v1continualcheckpointsstatus]

Continual checkpoint status

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request]

**Implementation limit:** Acknowledgement-only implementation: returns \{ok:true}; no checkpoint persistence, recovery, or component registration occurs in this handler.

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:** `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!({"ok": true})
```

### 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 continual_checkpoint_status() -> Result<impl IntoResponse, DaemonError> {
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9624`. Registration: `akasha-daemon/src/main.rs:4521`.

<a id="post-v1-continual-recover" />

## POST `/v1/continual/recover` [#post-v1continualrecover]

Continual recover

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-1]

**Implementation limit:** Acknowledgement-only implementation: returns \{ok:true}; no checkpoint persistence, recovery, or component registration occurs in this handler.

**Json** — `ContinualRecoverReq`

| Field           | Rust type | Required on input | Notes |
| --------------- | --------- | ----------------- | ----- |
| `checkpoint_id` | `String`  | Yes               |       |

```rust
struct ContinualRecoverReq {
    #[allow(dead_code)]
    checkpoint_id: String,
}
```

### Response [#response-1]

**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!({"ok": true})
```

### 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 continual_recover(
        Json(_req): Json<ContinualRecoverReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9634`. Registration: `akasha-daemon/src/main.rs:4525`.

<a id="post-v1-continual-components" />

## POST `/v1/continual/components` [#post-v1continualcomponents]

Continual component register

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-2]

**Implementation limit:** Acknowledgement-only implementation: returns \{ok:true}; no checkpoint persistence, recovery, or component registration occurs in this handler.

**Json** — `ContinualComponentReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ContinualComponentReq {
    #[allow(dead_code)]
    id: String,
}
```

### Response [#response-2]

**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!({"ok": true})
```

### 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 continual_component_register(
        Json(_req): Json<ContinualComponentReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9646`. Registration: `akasha-daemon/src/main.rs:4526`.

<a id="post-v1-continual-components-delete" />

## POST `/v1/continual/components/delete` [#post-v1continualcomponentsdelete]

Continual component unregister

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-3]

**Implementation limit:** Acknowledgement-only implementation: returns \{ok:true}; no checkpoint persistence, recovery, or component registration occurs in this handler.

**Json** — `ContinualComponentReq`

| Field | Rust type | Required on input | Notes |
| ----- | --------- | ----------------- | ----- |
| `id`  | `String`  | Yes               |       |

```rust
struct ContinualComponentReq {
    #[allow(dead_code)]
    id: String,
}
```

### Response [#response-3]

**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!({"ok": true})
```

### 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 continual_component_unregister(
        Json(_req): Json<ContinualComponentReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9651`. Registration: `akasha-daemon/src/main.rs:4530`.

<a id="post-v1-continual-task-new" />

## POST `/v1/continual/task/new` [#post-v1continualtasknew]

Continual task new

| Availability         | Source contract           |
| -------------------- | ------------------------- |
| Registration         | `config.enable_continual` |
| Runtime service      | `continual`               |
| Handler dependencies | `Continual Learning`      |

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

### Request [#request-4]

**Json** — `ContinualTaskNewReq`

| Field         | Rust type        | Required on input         | Notes |
| ------------- | ---------------- | ------------------------- | ----- |
| `name`        | `String`         | Yes                       |       |
| `description` | `Option<String>` | No; optional or defaulted |       |

```rust
struct ContinualTaskNewReq {
    name: String,
    description: Option<String>,
}
```

### Response [#response-4]

**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::to_value(task_metadata).unwrap_or_default(),
```

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

Directly referenced error variants: `Internal`, `InvalidRequest`. 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 continual_task_new(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ContinualTaskNewReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();

        let namespace = db
            .namespace_id()
            .ok_or_else(|| DaemonError::InvalidRequest("No namespace ID available".to_string()))?;
        let description = req
            .description
            .unwrap_or_else(|| format!("Continual learning task: {}", req.name));

        let continual_registry = require_service!(state.continual_registry, "Continual Learning");
        let task_metadata = continual_registry
            .create_task(namespace, req.name.clone(), description)
            .await
            .map_err(|e| DaemonError::Internal(format!("Failed to create task: {}", e)))?;

        Ok(Json(
            serde_json::to_value(task_metadata).unwrap_or_default(),
        ))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9665`. Registration: `akasha-daemon/src/main.rs:4535`.

<a id="post-v1-continual-task-train" />

## POST `/v1/continual/task/train` [#post-v1continualtasktrain]

Continual task train

| Availability         | Source contract           |
| -------------------- | ------------------------- |
| Registration         | `config.enable_continual` |
| Runtime service      | `continual`               |
| Handler dependencies | `Continual Learning`      |

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

### Request [#request-5]

**Json** — `ContinualTaskTrainReq`

| Field           | Rust type                | Required on input | Notes |
| --------------- | ------------------------ | ----------------- | ----- |
| `task_id`       | `String`                 | Yes               |       |
| `training_data` | `Vec<serde_json::Value>` | Yes               |       |

```rust
struct ContinualTaskTrainReq {
    task_id: String,
    training_data: Vec<serde_json::Value>,
}
```

### Response [#response-5]

**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::to_value(result).unwrap_or_default()
```

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

Directly referenced error variants: `Internal`. 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 continual_task_train(
        Extension(_db): Extension<Arc<AkashaDB>>,
        State(state): State<AppState>,
        Json(req): Json<ContinualTaskTrainReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        state.usage_emitter.emit_continual_learning();

        let continual_registry = require_service!(state.continual_registry, "Continual Learning");
        let result = continual_registry
            .train_task(&req.task_id, req.training_data)
            .await
            .map_err(|e| DaemonError::Internal(format!("Training failed: {}", e)))?;

        Ok(Json(serde_json::to_value(result).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9696`. Registration: `akasha-daemon/src/main.rs:4536`.

<a id="post-v1-continual-task-stats" />

## POST `/v1/continual/task/stats` [#post-v1continualtaskstats]

Continual task stats

| Availability         | Source contract           |
| -------------------- | ------------------------- |
| Registration         | `config.enable_continual` |
| Runtime service      | `continual`               |
| Handler dependencies | `Continual Learning`      |

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

### Request [#request-6]

**Json** — `ContinualTaskStatsReq`

| Field       | Rust type        | Required on input         | Notes |
| ----------- | ---------------- | ------------------------- | ----- |
| `namespace` | `Option<String>` | No; optional or defaulted |       |

```rust
struct ContinualTaskStatsReq {
    namespace: Option<String>,
}
```

### 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
serde_json::to_value(stats).unwrap_or_default()
```

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

Directly referenced error variants: `Internal`. 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 continual_task_stats(
        Extension(_db): Extension<Arc<AkashaDB>>,
        State(state): State<AppState>,
        Json(req): Json<ContinualTaskStatsReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();

        let continual_registry = require_service!(state.continual_registry, "Continual Learning");
        let stats = continual_registry
            .get_statistics(req.namespace.as_deref())
            .await
            .map_err(|e| DaemonError::Internal(format!("Failed to get statistics: {}", e)))?;

        Ok(Json(serde_json::to_value(stats).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9718`. Registration: `akasha-daemon/src/main.rs:4537`.

<a id="post-v1-continual-task-evaluate" />

## POST `/v1/continual/task/evaluate` [#post-v1continualtaskevaluate]

Continual task evaluate

| Availability         | Source contract           |
| -------------------- | ------------------------- |
| Registration         | `config.enable_continual` |
| Runtime service      | `continual`               |
| Handler dependencies | `Continual Learning`      |

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

### Request [#request-7]

**Json** — `ContinualTaskEvaluateReq`

| Field       | Rust type                        | Required on input         | Notes |
| ----------- | -------------------------------- | ------------------------- | ----- |
| `task_id`   | `String`                         | Yes                       |       |
| `test_data` | `Option<Vec<serde_json::Value>>` | No; optional or defaulted |       |

```rust
struct ContinualTaskEvaluateReq {
    task_id: String,
    test_data: Option<Vec<serde_json::Value>>,
}
```

### Response [#response-7]

**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::to_value(result).unwrap_or_default()
```

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

Directly referenced error variants: `Internal`. 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 continual_task_evaluate(
        Extension(_db): Extension<Arc<AkashaDB>>,
        State(state): State<AppState>,
        Json(req): Json<ContinualTaskEvaluateReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();

        let continual_registry = require_service!(state.continual_registry, "Continual Learning");
        let result = continual_registry
            .evaluate_task(&req.task_id, req.test_data)
            .await
            .map_err(|e| DaemonError::Internal(format!("Evaluation failed: {}", e)))?;

        Ok(Json(serde_json::to_value(result).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9740`. Registration: `akasha-daemon/src/main.rs:4538`.

<a id="post-v1-continual-task-delete" />

## POST `/v1/continual/task/delete` [#post-v1continualtaskdelete]

Continual task delete

| Availability         | Source contract           |
| -------------------- | ------------------------- |
| Registration         | `config.enable_continual` |
| Runtime service      | `continual`               |
| Handler dependencies | `Continual Learning`      |

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

### Request [#request-8]

**Json** — `ContinualTaskDeleteReq`

| Field     | Rust type | Required on input | Notes |
| --------- | --------- | ----------------- | ----- |
| `task_id` | `String`  | Yes               |       |

```rust
struct ContinualTaskDeleteReq {
    task_id: String,
}
```

### 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!({"ok": true})
```

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

Directly referenced error variants: `Internal`. 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 continual_task_delete(
        State(state): State<AppState>,
        Json(req): Json<ContinualTaskDeleteReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let continual_registry = require_service!(state.continual_registry, "Continual Learning");
        continual_registry
            .delete_task(&req.task_id)
            .await
            .map_err(|e| DaemonError::Internal(format!("Delete failed: {e}")))?;
        Ok(Json(serde_json::json!({"ok": true})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9761`. Registration: `akasha-daemon/src/main.rs:4539`.

<a id="post-v1-continual-task-consolidate" />

## POST `/v1/continual/task/consolidate` [#post-v1continualtaskconsolidate]

Continual task consolidate

| Availability         | Source contract           |
| -------------------- | ------------------------- |
| Registration         | `config.enable_continual` |
| Runtime service      | `continual`               |
| Handler dependencies | `Continual Learning`      |

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

### Request [#request-9]

**Json** — `ContinualTaskConsolidateReq`

| Field       | Rust type        | Required on input         | Notes            |
| ----------- | ---------------- | ------------------------- | ---------------- |
| `namespace` | `Option<String>` | No; optional or defaulted | Serde: `default` |

```rust
struct ContinualTaskConsolidateReq {
    #[serde(default)]
    namespace: Option<String>,
}
```

### Response [#response-9]

**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::to_value(result).unwrap_or_default()
```

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

Directly referenced error variants: `Internal`, `InvalidRequest`. 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 continual_task_consolidate(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<AkashaDB>>,
        Json(req): Json<ContinualTaskConsolidateReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        state.usage_emitter.emit_continual_learning();
        let namespace = if let Some(ns_hex) = req.namespace {
            let ns_bytes = hex::decode(&ns_hex)
                .map_err(|_| DaemonError::InvalidRequest("Invalid namespace hex".to_string()))?;
            if ns_bytes.len() != 16 {
                return Err(DaemonError::InvalidRequest(
                    "Namespace must be 16 bytes".to_string(),
                ));
            }
            let mut arr = [0u8; 16];
            arr.copy_from_slice(&ns_bytes);
            CoreNamespaceId(arr)
        } else {
            db.namespace_id()
                .ok_or_else(|| DaemonError::InvalidRequest("No namespace ID available".to_string()))?
        };

        let continual_registry = require_service!(state.continual_registry, "Continual Learning");
        let result = continual_registry
            .consolidate_knowledge(namespace)
            .await
            .map_err(|e| DaemonError::Internal(format!("Consolidation failed: {}", e)))?;

        Ok(Json(serde_json::to_value(result).unwrap_or_default()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:9780`. Registration: `akasha-daemon/src/main.rs:4540`.

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

## GET `/v1/continual/health` [#get-v1continualhealth]

Continual health

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### 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>`

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-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 continual_health(State(state): State<AppState>) -> Result<impl IntoResponse, DaemonError> {
        service_health_payload(&state, "continual").await
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:10297`. Registration: `akasha-daemon/src/main.rs:4544`.

<a id="post-v1-continual-task-pause" />

## POST `/v1/continual/task/pause` [#post-v1continualtaskpause]

Continual task pause

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-11]

**Json** — `ContinualTaskPauseReq`

| Field     | Rust type        | Required on input         | Notes |
| --------- | ---------------- | ------------------------- | ----- |
| `task_id` | `Option<String>` | No; optional or defaulted |       |

```rust
struct ContinualTaskPauseReq {
    #[allow(dead_code)]
    task_id: Option<String>,
}
```

### 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!({"ok": true, "status": "paused"})
```

### 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 continual_task_pause(
        State(state): State<AppState>,
        Json(_req): Json<ContinualTaskPauseReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        Ok(Json(serde_json::json!({"ok": true, "status": "paused"})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11116`. Registration: `akasha-daemon/src/main.rs:4545`.

<a id="post-v1-continual-task-resume" />

## POST `/v1/continual/task/resume` [#post-v1continualtaskresume]

Continual task resume

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-12]

**Json** — `ContinualTaskPauseReq`

| Field     | Rust type        | Required on input         | Notes |
| --------- | ---------------- | ------------------------- | ----- |
| `task_id` | `Option<String>` | No; optional or defaulted |       |

```rust
struct ContinualTaskPauseReq {
    #[allow(dead_code)]
    task_id: Option<String>,
}
```

### Response [#response-12]

**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!({"ok": true, "status": "active"})
```

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

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 continual_task_resume(
        State(state): State<AppState>,
        Json(_req): Json<ContinualTaskPauseReq>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        Ok(Json(serde_json::json!({"ok": true, "status": "active"})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11124`. Registration: `akasha-daemon/src/main.rs:4546`.

<a id="get-v1-continual-config" />

## GET `/v1/continual/config` [#get-v1continualconfig]

Continual config get

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-13]

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-13]

**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
cfg.clone()
```

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

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 continual_config_get(
        State(state): State<AppState>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let cfg = state.continual_config.read().await;
        Ok(Json(cfg.clone()))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11132`. Registration: `akasha-daemon/src/main.rs:4547`.

<a id="put-v1-continual-config" />

## PUT `/v1/continual/config` [#put-v1continualconfig]

Continual config update

| Availability         | Source contract                            |
| -------------------- | ------------------------------------------ |
| Registration         | `config.enable_continual`                  |
| Runtime service      | `continual`                                |
| Handler dependencies | See handler source and return expressions. |

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

### Request [#request-14]

**Json** — `serde_json::Value`

This handler accepts dynamic JSON. The field accesses below are source observations, not a fabricated required-field schema.

### Response [#response-14]

**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!({"ok": true, "config": *cfg})
```

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

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 continual_config_update(
        State(state): State<AppState>,
        Json(body): Json<serde_json::Value>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let mut cfg = state.continual_config.write().await;
        *cfg = body.clone();
        Ok(Json(serde_json::json!({"ok": true, "config": *cfg})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/main.rs:11140`. Registration: `akasha-daemon/src/main.rs:4547`.