# Learning Isolation

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

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



This reference covers **7 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/quarantine/items`             | [Quarantine list items](#get-v1-quarantine-items)               |
| `GET`  | `/v1/quarantine/items/:id`         | [Quarantine get item](#get-v1-quarantine-items-id)              |
| `POST` | `/v1/quarantine/items/:id/approve` | [Quarantine approve item](#post-v1-quarantine-items-id-approve) |
| `POST` | `/v1/quarantine/items/:id/reject`  | [Quarantine reject item](#post-v1-quarantine-items-id-reject)   |
| `POST` | `/v1/quarantine/test-gate`         | [Quarantine run test gate](#post-v1-quarantine-test-gate)       |
| `GET`  | `/v1/quarantine/policies`          | [Quarantine list policies](#get-v1-quarantine-policies)         |
| `GET`  | `/v1/quarantine/stats`             | [Quarantine stats](#get-v1-quarantine-stats)                    |

<a id="get-v1-quarantine-items" />

## GET `/v1/quarantine/items` [#get-v1quarantineitems]

List quarantined items, optionally filtered by status. GET /v1/quarantine/items?status=pending\&limit=100

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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]

**Query** — `QuarantineListParams`

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

```rust
struct QuarantineListParams {
    status: Option<String>,
    limit: Option<usize>,
}
```

### 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!({
        "items": results,
        "count": results.len()
    })
```

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

Directly referenced error variants: `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 quarantine_list_items(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<akasha::AkashaDB>>,
        Query(params): Query<QuarantineListParams>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        ensure_quarantine_keyspace(&db).await?;

        let limit = params.limit.unwrap_or(200).min(1000);

        let mut qb = db.query(QUARANTINE_KEYSPACE).limit(limit);

        // Apply status filter if provided
        if let Some(ref status) = params.status {
            qb = qb.filter("status", "==", status);
        }

        let results = qb
            .execute()
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;

        Ok(Json(serde_json::json!({
            "items": results,
            "count": results.len()
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:225`. Registration: `akasha-daemon/src/quarantine.rs:445`.

<a id="get-v1-quarantine-items-id" />

## GET `/v1/quarantine/items/:id` [#get-v1quarantineitemsid]

Get a single quarantined item with its test gate results. GET /v1/quarantine/items/:id

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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-1]

**Path** — `String`

```json
{
  "type": "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!({"item": item})
```

### 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 quarantine_get_item(
        Path(id): Path<String>,
        State(state): State<AppState>,
        Extension(db): Extension<Arc<akasha::AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        ensure_quarantine_keyspace(&db).await?;

        let item = load_quarantine_item(&db, &id).await?;

        Ok(Json(serde_json::json!({"item": item})))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:256`. Registration: `akasha-daemon/src/quarantine.rs:446`.

<a id="post-v1-quarantine-items-id-approve" />

## POST `/v1/quarantine/items/:id/approve` [#post-v1quarantineitemsidapprove]

Approve a quarantined item, setting its status to "approved". POST /v1/quarantine/items/:id/approve

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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-2]

**Path** — `String`

```json
{
  "type": "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!({
        "id": item.id,
        "status": "approved",
        "updated_at": item.updated_at
    })
```

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

Directly referenced error variants: `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 quarantine_approve_item(
        Path(id): Path<String>,
        State(state): State<AppState>,
        Extension(db): Extension<Arc<akasha::AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        ensure_quarantine_keyspace(&db).await?;

        let mut item = load_quarantine_item(&db, &id).await?;

        if item.status != "pending" {
            return Err(DaemonError::InvalidRequest(format!(
                "item '{}' is not in pending state (current: {})",
                id, item.status
            )));
        }

        item.status = "approved".to_string();
        item.updated_at = Utc::now().to_rfc3339();

        save_quarantine_item(&db, &item).await?;

        Ok(Json(serde_json::json!({
            "id": item.id,
            "status": "approved",
            "updated_at": item.updated_at
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:272`. Registration: `akasha-daemon/src/quarantine.rs:447`.

<a id="post-v1-quarantine-items-id-reject" />

## POST `/v1/quarantine/items/:id/reject` [#post-v1quarantineitemsidreject]

Reject a quarantined item, setting its status to "rejected". POST /v1/quarantine/items/:id/reject

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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-3]

**Path** — `String`

```json
{
  "type": "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!({
        "id": item.id,
        "status": "rejected",
        "updated_at": item.updated_at
    })
```

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

Directly referenced error variants: `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 quarantine_reject_item(
        Path(id): Path<String>,
        State(state): State<AppState>,
        Extension(db): Extension<Arc<akasha::AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        ensure_quarantine_keyspace(&db).await?;

        let mut item = load_quarantine_item(&db, &id).await?;

        if item.status != "pending" {
            return Err(DaemonError::InvalidRequest(format!(
                "item '{}' is not in pending state (current: {})",
                id, item.status
            )));
        }

        item.status = "rejected".to_string();
        item.updated_at = Utc::now().to_rfc3339();

        save_quarantine_item(&db, &item).await?;

        Ok(Json(serde_json::json!({
            "id": item.id,
            "status": "rejected",
            "updated_at": item.updated_at
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:304`. Registration: `akasha-daemon/src/quarantine.rs:451`.

<a id="post-v1-quarantine-test-gate" />

## POST `/v1/quarantine/test-gate` [#post-v1quarantinetest-gate]

Run a test gate on a quarantined item and record the result. POST /v1/quarantine/test-gate

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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-4]

**Json** — `TestGateRequest`

| Field       | Rust type     | Required on input         | Notes                                                |
| ----------- | ------------- | ------------------------- | ---------------------------------------------------- |
| `item_id`   | `String`      | Yes                       |                                                      |
| `gate`      | `String`      | Yes                       |                                                      |
| `threshold` | `Option<f64>` | No; optional or defaulted | Optional threshold override (defaults per gate type) |

```rust
struct TestGateRequest {
    item_id: String,
    gate: String, // "confidence-score" or "anomaly-detection"
    /// Optional threshold override (defaults per gate type)
    threshold: Option<f64>,
}
```

### 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::json!({
        "item_id": req.item_id,
        "gate": req.gate,
        "passed": passed,
        "result": result
    })
```

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

Directly referenced error variants: `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 quarantine_run_test_gate(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<akasha::AkashaDB>>,
        Json(req): Json<TestGateRequest>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        ensure_quarantine_keyspace(&db).await?;

        let mut item = load_quarantine_item(&db, &req.item_id).await?;

        let result = match req.gate.as_str() {
            "confidence-score" => {
                let threshold = req.threshold.unwrap_or(DEFAULT_CONFIDENCE_THRESHOLD);
                evaluate_confidence_score(item.trust_score, threshold)
            }
            "anomaly-detection" => {
                let threshold = req.threshold.unwrap_or(ANOMALY_LOWER_BOUND);
                evaluate_anomaly_detection(item.trust_score, threshold)
            }
            other => {
                return Err(DaemonError::InvalidRequest(format!(
                    "unknown test gate '{}'; supported: confidence-score, anomaly-detection",
                    other
                )));
            }
        };

        let passed = result.passed;

        // Append the test result to the item's history
        item.test_results.push(result.clone());
        item.updated_at = Utc::now().to_rfc3339();

        save_quarantine_item(&db, &item).await?;

        Ok(Json(serde_json::json!({
            "item_id": req.item_id,
            "gate": req.gate,
            "passed": passed,
            "result": result
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:336`. Registration: `akasha-daemon/src/quarantine.rs:455`.

<a id="get-v1-quarantine-policies" />

## GET `/v1/quarantine/policies` [#get-v1quarantinepolicies]

Return quarantine policies. GET /v1/quarantine/policies

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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-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<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!({
        "policies": policies,
        "count": policies.len()
    })
```

### 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 quarantine_list_policies(
        State(state): State<AppState>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        let policies = default_policies();
        Ok(Json(serde_json::json!({
            "policies": policies,
            "count": policies.len()
        })))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:382`. Registration: `akasha-daemon/src/quarantine.rs:456`.

<a id="get-v1-quarantine-stats" />

## GET `/v1/quarantine/stats` [#get-v1quarantinestats]

Count quarantined items by status. GET /v1/quarantine/stats

| Availability         | Source contract                                                  |
| -------------------- | ---------------------------------------------------------------- |
| Registration         | `always registered; requires database at runtime`                |
| 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.
&#x2A;*JSON field accesses in handler:** `status`. Nested lookups are included; this list alone does not establish requiredness.

### 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::json!(resp)
```

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

Directly referenced error variants: `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 quarantine_stats(
        State(state): State<AppState>,
        Extension(db): Extension<Arc<akasha::AkashaDB>>,
    ) -> Result<impl IntoResponse, DaemonError> {
        state.record_http_request();
        ensure_quarantine_keyspace(&db).await?;

        let results = db
            .query(QUARANTINE_KEYSPACE)
            .limit(10_000)
            .execute()
            .await
            .map_err(|e| DaemonError::InvalidRequest(e.to_string()))?;

        let mut pending: usize = 0;
        let mut approved: usize = 0;
        let mut rejected: usize = 0;
        let total = results.len();

        for row in &results {
            let status = row
                .data
                .get("status")
                .and_then(|v| v.as_str())
                .unwrap_or("unknown");
            match status {
                "pending" => pending += 1,
                "approved" => approved += 1,
                "rejected" => rejected += 1,
                _ => {}
            }
        }

        let resp = QuarantineStatsResponse {
            total,
            pending,
            approved,
            rejected,
        };

        Ok(Json(serde_json::json!(resp)))
    }
    ```
  </Accordion>
</Accordions>

Source: `akasha-daemon/src/quarantine.rs:396`. Registration: `akasha-daemon/src/quarantine.rs:457`.