zeroclaw-labs/zeroclaw · error · anyhow::Error

purge_namespace not supported by this memory backend

Error message

purge_namespace not supported by this memory backend

What it means

When the release publishes a checksum asset (name exactly "sha256sums", "sha256sums.txt", or "*.sha256sums" — see find_sha256sums_url, src/commands/update.rs:334), verify_download_checksum fetches it before the archive is unpacked and bails on any non-2xx status. The posture is deliberately asymmetric: if no checksum asset exists, verification is skipped with a WARN; once the release advertises one, a failed fetch aborts the update rather than silently skipping integrity verification. Nothing has been written to staging when this fires.

Solutions

  1. Open the release page and confirm the sha256sums asset is actually present and downloadable, then retry `zeroclaw update`
  2. If rate-limited (403/429), wait for the window to reset and retry
  3. Check proxy/AV interference for the github download host
  4. If the asset is listed but permanently broken, report the release — do not try to bypass checksum verification

Example fix

# before
$ zeroclaw update
Error: SHA256SUMS fetch returned 404 Not Found

# after
$ # confirm the checksum asset is on the release page and fetchable
$ curl -fsSI "https://github.com/zeroclaw-labs/zeroclaw/releases/download/<tag>/sha256sums"
$ zeroclaw update
Defensive patterns

Strategy: retry

Validate before calling

// Preflight: confirm the checksum asset answers before updating.
async fn sums_fetchable(client: &reqwest::Client, sums_url: &str) -> bool {
    client
        .head(sums_url)
        .send()
        .await
        .map(|r| r.status().is_success())
        .unwrap_or(false)
}

Try / catch

if let Err(e) = update::run(version, force).await {
    if e.to_string().contains("SHA256SUMS fetch returned") {
        // Transient CDN/rate-limit failure in most cases: retry once after
        // a short backoff. If the asset is permanently missing, treat it as
        // a broken release and report — never downgrade to skipping
        // checksum verification for an advertised sums asset.
    }
}

Prevention

When it happens

Trigger: `zeroclaw update` on a release whose metadata lists a SHA256SUMS-family asset whose fetch then fails: 404 from a partially-published or re-uploaded release, 403/429 CDN rate limiting, or a proxy blocking the download host for that one request.

Common situations: Release published with checksums uploaded late or replaced mid-rollout; corporate proxy intermittently failing large-file or extra requests; rate-limited shared egress IP.

Related errors

AI-assisted analysis of zeroclaw-labs/zeroclaw@88bb9c8533 (2026-08-23). Data as JSON: /api/errors/029b7cb43bc37ab9. Report an issue: GitHub.

Appendix: source

Thrown at crates/zeroclaw-api/src/memory_traits.rs:321

    ) -> anyhow::Result<Vec<MemoryEntry>>;

    /// Remove a memory by key. Deletes every row matching `key`, regardless
    /// of agent attribution. Agent-scoped callers (the `AgentScopedMemory`
    /// wrapper) use [`forget_for_agent`](Self::forget_for_agent) instead.
    async fn forget(&self, key: &str) -> anyhow::Result<bool>;

    /// Remove the row matching `(key, agent_id)`. Siblings of the same key
    /// under other agents are untouched. Returns `true` if a row was
    /// removed. Required: no safe default exists for backends or wrappers
    /// that can hold more than one row per `key` — the unscoped `forget`
    /// would destroy sibling rows.
    async fn forget_for_agent(&self, key: &str, agent_id: &str) -> anyhow::Result<bool>;

    /// Remove all memories whose `namespace` field equals the given value.
    /// Returns the number of deleted entries.
    /// Default: returns unsupported error. Backends that support bulk deletion override this.
    async fn purge_namespace(&self, _namespace: &str) -> anyhow::Result<usize> {
        anyhow::bail!("purge_namespace not supported by this memory backend")
    }

    /// Remove all memories in a session.
    /// Returns the number of deleted entries.
    /// Default: returns unsupported error. Backends that support bulk deletion override this.
    async fn purge_session(&self, _session_id: &str) -> anyhow::Result<usize> {
        anyhow::bail!("purge_session not supported by this memory backend")
    }

    /// Remove all memories in a session for one agent.
    /// Returns the number of deleted entries.
    /// Default: returns unsupported error. Backends with per-agent storage
    /// override this; agent-scoped wrappers use it instead of composing a
    /// session list with key-only deletes.
    async fn purge_session_for_agent(
        &self,
        _session_id: &str,
        _agent_id: &str,

View on GitHub (pinned to 88bb9c8533)