TaskFlow
DashboardFreewriteWhiteboardsProjectsCRMTasksNotificationsSettingsAgent TowerAPI Docs
OpenClaw Docs
?

User

Member

Caricamento in corso...

Home
Progetti
Task
Notifiche
CRM

    OpenClaw

    Documentation Mirror

    Documentation Overview

    Docs

    Auth credential semantics
    Scheduled tasks
    Hooks
    Automation & tasks
    Standing orders
    Task flow
    Background tasks
    BlueBubbles
    Broadcast groups
    Channel routing
    Discord
    Feishu
    Google Chat
    Group messages
    Groups
    iMessage
    Chat channels
    IRC
    LINE
    Channel location parsing
    Matrix
    Matrix migration
    Matrix push rules for quiet previews
    Mattermost
    Microsoft Teams
    Nextcloud Talk
    Nostr
    Pairing
    QA channel
    QQ bot
    Signal
    Slack
    Synology Chat
    Telegram
    Tlon
    Channel troubleshooting
    Twitch
    WeChat
    WhatsApp
    Yuanbao
    Zalo
    Zalo personal
    CI pipeline
    ACP
    Agent
    Agents
    Approvals
    Backup
    Browser
    Channels
    Clawbot
    `openclaw commitments`
    Completion
    Config
    Configure
    Cron
    Daemon
    Dashboard
    Devices
    Directory
    DNS
    Docs
    Doctor
    Flows (redirect)
    Gateway
    Health
    Hooks
    CLI reference
    Inference CLI
    Logs
    MCP
    Memory
    Message
    Migrate
    Models
    Node
    Nodes
    Onboard
    Pairing
    Plugins
    Proxy
    QR
    Reset
    Sandbox CLI
    Secrets
    Security
    Sessions
    Setup
    Skills
    Status
    System
    `openclaw tasks`
    TUI
    Uninstall
    Update
    Voicecall
    Webhooks
    Wiki
    Active memory
    Agent runtime
    Agent loop
    Agent runtimes
    Agent workspace
    Gateway architecture
    Channel docking
    Inferred commitments
    Compaction
    Context
    Context engine
    Delegate architecture
    Dreaming
    Experimental features
    Features
    Markdown formatting
    Memory overview
    Builtin memory engine
    Honcho memory
    QMD memory engine
    Memory search
    Messages
    Model failover
    Model providers
    Models CLI
    Multi-agent routing
    OAuth
    OpenClaw App SDK
    Presence
    QA overview
    Matrix QA
    Command queue
    Steering queue
    Retry policy
    Session management
    Session pruning
    Session tools
    SOUL.md personality guide
    Streaming and chunking
    System prompt
    Timezones
    TypeBox
    Typing indicators
    Usage tracking
    Date and time
    Node + tsx crash
    Diagnostics flags
    Authentication
    Background exec and process tool
    Bonjour discovery
    Bridge protocol
    CLI backends
    Configuration — agents
    Configuration — channels
    Configuration — tools and custom providers
    Configuration
    Configuration examples
    Configuration reference
    Diagnostics export
    Discovery and transports
    Doctor
    Gateway lock
    Health checks
    Heartbeat
    Gateway runbook
    Local models
    Gateway logging
    Multiple gateways
    Network model
    OpenAI chat completions
    OpenResponses API
    OpenShell
    OpenTelemetry export
    Gateway-owned pairing
    Prometheus metrics
    Gateway protocol
    Remote access
    Remote gateway setup
    Sandbox vs tool policy vs elevated
    Sandboxing
    Secrets management
    Secrets apply plan contract
    Security audit checks
    Security
    Tailscale
    Tools invoke API
    Troubleshooting
    Trusted proxy auth
    Debugging
    Environment variables
    FAQ
    FAQ: first-run setup
    FAQ: models and auth
    GPT-5.5 / Codex agentic parity
    GPT-5.5 / Codex parity maintainer notes
    Help
    Scripts
    Testing
    Testing: live suites
    General troubleshooting
    OpenClaw
    Ansible
    Azure
    Bun (experimental)
    ClawDock
    Release channels
    DigitalOcean
    Docker
    Docker VM runtime
    exe.dev
    Fly.io
    GCP
    Hetzner
    Hostinger
    Install
    Installer internals
    Kubernetes
    macOS VMs
    Migration guide
    Migrating from Claude
    Migrating from Hermes
    Nix
    Node.js
    Northflank
    Oracle Cloud
    Podman
    Railway
    Raspberry Pi
    Render
    Uninstall
    Updating
    Logging
    Network
    Audio and voice notes
    Camera capture
    Image and media support
    Nodes
    Location command
    Media understanding
    Talk mode
    Node troubleshooting
    Voice wake
    Pi integration architecture
    Pi development workflow
    Android app
    Platforms
    iOS app
    Linux app
    Gateway on macOS
    Canvas
    Gateway lifecycle
    macOS dev setup
    Health checks (macOS)
    Menu bar icon
    macOS logging
    Menu bar
    Peekaboo bridge
    macOS permissions
    Remote control
    macOS signing
    Skills (macOS)
    Voice overlay
    Voice wake (macOS)
    WebChat (macOS)
    macOS IPC
    macOS app
    Windows
    Plugin internals
    Plugin architecture internals
    Building plugins
    Plugin bundles
    Codex Computer Use
    Codex harness
    Community plugins
    Plugin compatibility
    Google Meet plugin
    Plugin hooks
    Plugin manifest
    Memory LanceDB
    Memory wiki
    Message presentation
    Agent harness plugins
    Building channel plugins
    Channel turn kernel
    Plugin entry points
    Plugin SDK migration
    Plugin SDK overview
    Building provider plugins
    Plugin runtime helpers
    Plugin setup and config
    Plugin SDK subpaths
    Plugin testing
    Skill workshop plugin
    Voice call plugin
    Webhooks plugin
    Zalo personal plugin
    OpenProse
    Alibaba Model Studio
    Anthropic
    Arcee AI
    Azure Speech
    Amazon Bedrock
    Amazon Bedrock Mantle
    Chutes
    Claude Max API proxy
    Cloudflare AI gateway
    ComfyUI
    Deepgram
    Deepinfra
    DeepSeek
    ElevenLabs
    Fal
    Fireworks
    GitHub Copilot
    GLM (Zhipu)
    Google (Gemini)
    Gradium
    Groq
    Hugging Face (inference)
    Provider directory
    Inferrs
    Inworld
    Kilocode
    LiteLLM
    LM Studio
    MiniMax
    Mistral
    Model provider quickstart
    Moonshot AI
    NVIDIA
    Ollama
    OpenAI
    OpenCode
    OpenCode Go
    OpenRouter
    Perplexity
    Qianfan
    Qwen
    Runway
    SGLang
    StepFun
    Synthetic
    Tencent Cloud (TokenHub)
    Together AI
    Venice AI
    Vercel AI gateway
    vLLM
    Volcengine (Doubao)
    Vydra
    xAI
    Xiaomi MiMo
    Z.AI
    Default AGENTS.md
    Release policy
    API usage and costs
    Credits
    Device model database
    Full release validation
    Memory configuration reference
    OpenClaw App SDK API design
    Prompt caching
    Rich output protocol
    RPC adapters
    SecretRef credential surface
    Session management deep dive
    AGENTS.md template
    BOOT.md template
    BOOTSTRAP.md template
    HEARTBEAT.md template
    IDENTITY template
    SOUL.md template
    TOOLS.md template
    USER template
    Tests
    Token use and costs
    Transcript hygiene
    Onboarding reference
    Contributing to the threat model
    Threat model (MITRE ATLAS)
    Formal verification (security models)
    Network proxy
    Agent bootstrapping
    Docs directory
    Getting started
    Docs hubs
    OpenClaw lore
    Onboarding (macOS app)
    Onboarding overview
    Personal assistant setup
    Setup
    Showcase
    Onboarding (CLI)
    CLI automation
    CLI setup reference
    ACP agents
    ACP agents — setup
    Agent send
    apply_patch tool
    Brave search
    Browser (OpenClaw-managed)
    Browser control API
    Browser troubleshooting
    Browser login
    WSL2 + Windows + remote Chrome CDP troubleshooting
    BTW side questions
    ClawHub
    Code execution
    Creating skills
    Diffs
    DuckDuckGo search
    Elevated mode
    Exa search
    Exec tool
    Exec approvals
    Exec approvals — advanced
    Firecrawl
    Gemini search
    Grok search
    Image generation
    Tools and plugins
    Kimi search
    LLM task
    Lobster
    Tool-loop detection
    Media overview
    MiniMax search
    Multi-agent sandbox and tools
    Music generation
    Ollama web search
    PDF tool
    Perplexity search
    Plugins
    Reactions
    SearXNG search
    Skills
    Skills config
    Slash commands
    Sub-agents
    Tavily
    Thinking levels
    Tokenjuice
    Trajectory bundles
    Text-to-speech
    Video generation
    Web search
    Web fetch
    Linux server
    Control UI
    Dashboard
    Web
    TUI
    WebChat

    OpenAPI Specs

    openapi
    TaskFlow
    docs/openclaw
    Original Docs

    Real-time Synchronized Documentation

    Last sync: 01/05/2026 07:04:32

    Note: This content is mirrored from docs.openclaw.ai and is subject to their terms and conditions.

    OpenClaw Docs

    v2.4.0 Production

    Last synced: Today, 22:00

    Technical reference for the OpenClaw framework. Real-time synchronization with the official documentation engine.

    Use this file to discover all available pages before exploring further.

    Matrix migration

    Upgrade from the previous public

    text
    matrix
    plugin to the current implementation.

    For most users, the upgrade is in place:

    • the plugin stays
      text
      @openclaw/matrix
    • the channel stays
      text
      matrix
    • your config stays under
      text
      channels.matrix
    • cached credentials stay under
      text
      ~/.openclaw/credentials/matrix/
    • runtime state stays under
      text
      ~/.openclaw/matrix/

    You do not need to rename config keys or reinstall the plugin under a new name.

    What the migration does automatically

    When the gateway starts, and when you run

    text
    openclaw doctor --fix
    , OpenClaw tries to repair old Matrix state automatically. Before any actionable Matrix migration step mutates on-disk state, OpenClaw creates or reuses a focused recovery snapshot.

    When you use

    text
    openclaw update
    , the exact trigger depends on how OpenClaw is installed:

    • source installs run
      text
      openclaw doctor --fix
      during the update flow, then restart the gateway by default
    • package-manager installs update the package, run a non-interactive doctor pass, then rely on the default gateway restart so startup can finish Matrix migration
    • if you use
      text
      openclaw update --no-restart
      , startup-backed Matrix migration is deferred until you later run
      text
      openclaw doctor --fix
      and restart the gateway

    Automatic migration covers:

    • creating or reusing a pre-migration snapshot under
      text
      ~/Backups/openclaw-migrations/
    • reusing your cached Matrix credentials
    • keeping the same account selection and
      text
      channels.matrix
      config
    • moving the oldest flat Matrix sync store into the current account-scoped location
    • moving the oldest flat Matrix crypto store into the current account-scoped location when the target account can be resolved safely
    • extracting a previously saved Matrix room-key backup decryption key from the old rust crypto store, when that key exists locally
    • reusing the most complete existing token-hash storage root for the same Matrix account, homeserver, and user when the access token changes later
    • scanning sibling token-hash storage roots for pending encrypted-state restore metadata when the Matrix access token changed but the account/device identity stayed the same
    • restoring backed-up room keys into the new crypto store on the next Matrix startup

    Snapshot details:

    • OpenClaw writes a marker file at
      text
      ~/.openclaw/matrix/migration-snapshot.json
      after a successful snapshot so later startup and repair passes can reuse the same archive.
    • These automatic Matrix migration snapshots back up config + state only (
      text
      includeWorkspace: false
      ).
    • If Matrix only has warning-only migration state, for example because
      text
      userId
      or
      text
      accessToken
      is still missing, OpenClaw does not create the snapshot yet because no Matrix mutation is actionable.
    • If the snapshot step fails, OpenClaw skips Matrix migration for that run instead of mutating state without a recovery point.

    About multi-account upgrades:

    • the oldest flat Matrix store (
      text
      ~/.openclaw/matrix/bot-storage.json
      and
      text
      ~/.openclaw/matrix/crypto/
      ) came from a single-store layout, so OpenClaw can only migrate it into one resolved Matrix account target
    • already account-scoped legacy Matrix stores are detected and prepared per configured Matrix account

    What the migration cannot do automatically

    The previous public Matrix plugin did not automatically create Matrix room-key backups. It persisted local crypto state and requested device verification, but it did not guarantee that your room keys were backed up to the homeserver.

    That means some encrypted installs can only be migrated partially.

    OpenClaw cannot automatically recover:

    • local-only room keys that were never backed up
    • encrypted state when the target Matrix account cannot be resolved yet because
      text
      homeserver
      ,
      text
      userId
      , or
      text
      accessToken
      are still unavailable
    • automatic migration of one shared flat Matrix store when multiple Matrix accounts are configured but
      text
      channels.matrix.defaultAccount
      is not set
    • custom plugin path installs that are pinned to a repo path instead of the standard Matrix package
    • a missing recovery key when the old store had backed-up keys but did not keep the decryption key locally

    Current warning scope:

    • custom Matrix plugin path installs are surfaced by both gateway startup and
      text
      openclaw doctor

    If your old installation had local-only encrypted history that was never backed up, some older encrypted messages may remain unreadable after the upgrade.

    Recommended upgrade flow

    1. Update OpenClaw and the Matrix plugin normally. Prefer plain

      text
      openclaw update
      without
      text
      --no-restart
      so startup can finish the Matrix migration immediately.

    2. Run:

      bash
      openclaw doctor --fix

      If Matrix has actionable migration work, doctor will create or reuse the pre-migration snapshot first and print the archive path.

    3. Start or restart the gateway.

    4. Check current verification and backup state:

      bash
      openclaw matrix verify status openclaw matrix verify backup status
    5. Put the recovery key for the Matrix account you are repairing in an account-specific environment variable. For a single default account,

      text
      MATRIX_RECOVERY_KEY
      is fine. For multiple accounts, use one variable per account, for example
      text
      MATRIX_RECOVERY_KEY_ASSISTANT
      , and add
      text
      --account assistant
      to the command.

    6. If OpenClaw tells you a recovery key is needed, run the command for the matching account:

      bash
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify backup restore --recovery-key-stdin printf '%s\n' "$MATRIX_RECOVERY_KEY_ASSISTANT" | openclaw matrix verify backup restore --recovery-key-stdin --account assistant
    7. If this device is still unverified, run the command for the matching account:

      bash
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify device --recovery-key-stdin printf '%s\n' "$MATRIX_RECOVERY_KEY_ASSISTANT" | openclaw matrix verify device --recovery-key-stdin --account assistant

      If the recovery key is accepted and backup is usable, but

      text
      Cross-signing verified
      is still
      text
      no
      , complete self-verification from another Matrix client:

      bash
      openclaw matrix verify self

      Accept the request in another Matrix client, compare the emoji or decimals, and type

      text
      yes
      only when they match. The command exits successfully only after
      text
      Cross-signing verified
      becomes
      text
      yes
      .

    8. If you are intentionally abandoning unrecoverable old history and want a fresh backup baseline for future messages, run:

      bash
      openclaw matrix verify backup reset --yes
    9. If no server-side key backup exists yet, create one for future recoveries:

      bash
      openclaw matrix verify bootstrap

    How encrypted migration works

    Encrypted migration is a two-stage process:

    1. Startup or
      text
      openclaw doctor --fix
      creates or reuses the pre-migration snapshot if encrypted migration is actionable.
    2. Startup or
      text
      openclaw doctor --fix
      inspects the old Matrix crypto store through the active Matrix plugin install.
    3. If a backup decryption key is found, OpenClaw writes it into the new recovery-key flow and marks room-key restore as pending.
    4. On the next Matrix startup, OpenClaw restores backed-up room keys into the new crypto store automatically.

    If the old store reports room keys that were never backed up, OpenClaw warns instead of pretending recovery succeeded.

    Common messages and what they mean

    Upgrade and detection messages

    text
    Matrix plugin upgraded in place.

    • Meaning: the old on-disk Matrix state was detected and migrated into the current layout.
    • What to do: nothing unless the same output also includes warnings.

    text
    Matrix migration snapshot created before applying Matrix upgrades.

    • Meaning: OpenClaw created a recovery archive before mutating Matrix state.
    • What to do: keep the printed archive path until you confirm migration succeeded.

    text
    Matrix migration snapshot reused before applying Matrix upgrades.

    • Meaning: OpenClaw found an existing Matrix migration snapshot marker and reused that archive instead of creating a duplicate backup.
    • What to do: keep the printed archive path until you confirm migration succeeded.

    text
    Legacy Matrix state detected at ... but channels.matrix is not configured yet.

    • Meaning: old Matrix state exists, but OpenClaw cannot map it to a current Matrix account because Matrix is not configured.
    • What to do: configure
      text
      channels.matrix
      , then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    Legacy Matrix state detected at ... but the new account-scoped target could not be resolved yet (need homeserver, userId, and access token for channels.matrix...).

    • Meaning: OpenClaw found old state, but it still cannot determine the exact current account/device root.
    • What to do: start the gateway once with a working Matrix login, or rerun
      text
      openclaw doctor --fix
      after cached credentials exist.

    text
    Legacy Matrix state detected at ... but multiple Matrix accounts are configured and channels.matrix.defaultAccount is not set.

    • Meaning: OpenClaw found one shared flat Matrix store, but it refuses to guess which named Matrix account should receive it.
    • What to do: set
      text
      channels.matrix.defaultAccount
      to the intended account, then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    Matrix legacy sync store not migrated because the target already exists (...)

    • Meaning: the new account-scoped location already has a sync or crypto store, so OpenClaw did not overwrite it automatically.
    • What to do: verify that the current account is the correct one before manually removing or moving the conflicting target.

    text
    Failed migrating Matrix legacy sync store (...)
    or
    text
    Failed migrating Matrix legacy crypto store (...)

    • Meaning: OpenClaw tried to move old Matrix state but the filesystem operation failed.
    • What to do: inspect filesystem permissions and disk state, then rerun
      text
      openclaw doctor --fix
      .

    text
    Legacy Matrix encrypted state detected at ... but channels.matrix is not configured yet.

    • Meaning: OpenClaw found an old encrypted Matrix store, but there is no current Matrix config to attach it to.
    • What to do: configure
      text
      channels.matrix
      , then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    Legacy Matrix encrypted state detected at ... but the account-scoped target could not be resolved yet (need homeserver, userId, and access token for channels.matrix...).

    • Meaning: the encrypted store exists, but OpenClaw cannot safely decide which current account/device it belongs to.
    • What to do: start the gateway once with a working Matrix login, or rerun
      text
      openclaw doctor --fix
      after cached credentials are available.

    text
    Legacy Matrix encrypted state detected at ... but multiple Matrix accounts are configured and channels.matrix.defaultAccount is not set.

    • Meaning: OpenClaw found one shared flat legacy crypto store, but it refuses to guess which named Matrix account should receive it.
    • What to do: set
      text
      channels.matrix.defaultAccount
      to the intended account, then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    Matrix migration warnings are present, but no on-disk Matrix mutation is actionable yet. No pre-migration snapshot was needed.

    • Meaning: OpenClaw detected old Matrix state, but the migration is still blocked on missing identity or credential data.
    • What to do: finish Matrix login or config setup, then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    Legacy Matrix encrypted state was detected, but the Matrix plugin helper is unavailable. Install or repair @openclaw/matrix so OpenClaw can inspect the old rust crypto store before upgrading.

    • Meaning: OpenClaw found old encrypted Matrix state, but it could not load the helper entrypoint from the Matrix plugin that normally inspects that store.
    • What to do: reinstall or repair the Matrix plugin (
      text
      openclaw plugins install @openclaw/matrix
      , or
      text
      openclaw plugins install ./path/to/local/matrix-plugin
      for a repo checkout), then rerun
      text
      openclaw doctor --fix
      or restart the gateway.
    • If npm reports the OpenClaw-owned Matrix package as deprecated, use the bundled plugin from a current packaged OpenClaw build or the local checkout path until a newer npm package is published.

    text
    Matrix plugin helper path is unsafe: ... Reinstall @openclaw/matrix and try again.

    • Meaning: OpenClaw found a helper file path that escapes the plugin root or fails plugin boundary checks, so it refused to import it.
    • What to do: reinstall the Matrix plugin from a trusted path, then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    - Failed creating a Matrix migration snapshot before repair: ...

    text
    - Skipping Matrix migration changes for now. Resolve the snapshot failure, then rerun "openclaw doctor --fix".

    • Meaning: OpenClaw refused to mutate Matrix state because it could not create the recovery snapshot first.
    • What to do: resolve the backup error, then rerun
      text
      openclaw doctor --fix
      or restart the gateway.

    text
    Failed migrating legacy Matrix client storage: ...

    • Meaning: the Matrix client-side fallback found old flat storage, but the move failed. OpenClaw now aborts that fallback instead of silently starting with a fresh store.
    • What to do: inspect filesystem permissions or conflicts, keep the old state intact, and retry after fixing the error.

    text
    Matrix is installed from a custom path: ...

    • Meaning: Matrix is pinned to a path install, so mainline updates do not automatically replace it with the repo's standard Matrix package.
    • What to do: reinstall with
      text
      openclaw plugins install @openclaw/matrix
      when you want to return to the default Matrix plugin.
    • If npm reports the OpenClaw-owned Matrix package as deprecated, use the bundled plugin from a current packaged OpenClaw build until a newer npm package is published.

    Encrypted-state recovery messages

    text
    matrix: restored X/Y room key(s) from legacy encrypted-state backup

    • Meaning: backed-up room keys were restored successfully into the new crypto store.
    • What to do: usually nothing.

    text
    matrix: N legacy local-only room key(s) were never backed up and could not be restored automatically

    • Meaning: some old room keys existed only in the old local store and had never been uploaded to Matrix backup.
    • What to do: expect some old encrypted history to remain unavailable unless you can recover those keys manually from another verified client.

    text
    Legacy Matrix encrypted state for account "..." has backed-up room keys, but no local backup decryption key was found. Ask the operator to run "openclaw matrix verify backup restore --recovery-key-stdin" after upgrade if they have the recovery key.

    • Meaning: backup exists, but OpenClaw could not recover the recovery key automatically.
    • What to do: run
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify backup restore --recovery-key-stdin
      .

    text
    Failed inspecting legacy Matrix encrypted state for account "..." (...): ...

    • Meaning: OpenClaw found the old encrypted store, but it could not inspect it safely enough to prepare recovery.
    • What to do: rerun
      text
      openclaw doctor --fix
      . If it repeats, keep the old state directory intact and recover using another verified Matrix client plus
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify backup restore --recovery-key-stdin
      .

    text
    Legacy Matrix backup key was found for account "...", but .../recovery-key.json already contains a different recovery key. Leaving the existing file unchanged.

    • Meaning: OpenClaw detected a backup key conflict and refused to overwrite the current recovery-key file automatically.
    • What to do: verify which recovery key is correct before retrying any restore command.

    text
    Legacy Matrix encrypted state for account "..." cannot be fully converted automatically because the old rust crypto store does not expose all local room keys for export.

    • Meaning: this is the hard limit of the old storage format.
    • What to do: backed-up keys can still be restored, but local-only encrypted history may remain unavailable.

    text
    matrix: failed restoring room keys from legacy encrypted-state backup: ...

    • Meaning: the new plugin attempted restore but Matrix returned an error.
    • What to do: run
      text
      openclaw matrix verify backup status
      , then retry with
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify backup restore --recovery-key-stdin
      if needed.

    Manual recovery messages

    text
    Backup key is not loaded on this device. Run 'openclaw matrix verify backup restore' to load it and restore old room keys.

    • Meaning: OpenClaw knows you should have a backup key, but it is not active on this device.
    • What to do: run
      text
      openclaw matrix verify backup restore
      , or set
      text
      MATRIX_RECOVERY_KEY
      and run
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify backup restore --recovery-key-stdin
      if needed.

    text
    Store a recovery key with 'openclaw matrix verify device --recovery-key-stdin', then run 'openclaw matrix verify backup restore'.

    • Meaning: this device does not currently have the recovery key stored.
    • What to do: set
      text
      MATRIX_RECOVERY_KEY
      , run
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify device --recovery-key-stdin
      , then restore the backup.

    text
    Backup key mismatch on this device. Re-run 'openclaw matrix verify device --recovery-key-stdin' with the matching recovery key.

    • Meaning: the stored key does not match the active Matrix backup.
    • What to do: set
      text
      MATRIX_RECOVERY_KEY
      to the correct key and run
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify device --recovery-key-stdin
      .

    If you accept losing unrecoverable old encrypted history, you can instead reset the current backup baseline with

    text
    openclaw matrix verify backup reset --yes
    . When the stored backup secret is broken, that reset may also recreate secret storage so the new backup key can load correctly after restart.

    text
    Backup trust chain is not verified on this device. Re-run 'openclaw matrix verify device --recovery-key-stdin'.

    • Meaning: the backup exists, but this device does not trust the cross-signing chain strongly enough yet.
    • What to do: set
      text
      MATRIX_RECOVERY_KEY
      and run
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify device --recovery-key-stdin
      .

    text
    Matrix recovery key is required

    • Meaning: you tried a recovery step without supplying a recovery key when one was required.
    • What to do: rerun the command with
      text
      --recovery-key-stdin
      , for example
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify device --recovery-key-stdin
      .

    text
    Invalid Matrix recovery key: ...

    • Meaning: the provided key could not be parsed or did not match the expected format.
    • What to do: retry with the exact recovery key from your Matrix client or recovery-key file.

    text
    Matrix recovery key was applied, but this device still lacks full Matrix identity trust.

    • Meaning: OpenClaw could apply the recovery key, but Matrix still has not established full cross-signing identity trust for this device. Check the command output for
      text
      Recovery key accepted
      ,
      text
      Backup usable
      ,
      text
      Cross-signing verified
      , and
      text
      Device verified by owner
      .
    • What to do: run
      text
      openclaw matrix verify self
      , accept the request in another Matrix client, compare the SAS, and type
      text
      yes
      only when it matches. The command waits for full Matrix identity trust before reporting success. Use
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify bootstrap --recovery-key-stdin --force-reset-cross-signing
      only when you intentionally want to replace the current cross-signing identity.

    text
    Matrix key backup is not active on this device after loading from secret storage.

    • Meaning: secret storage did not produce an active backup session on this device.
    • What to do: verify the device first, then recheck with
      text
      openclaw matrix verify backup status
      .

    text
    Matrix crypto backend cannot load backup keys from secret storage. Verify this device with 'openclaw matrix verify device --recovery-key-stdin' first.

    • Meaning: this device cannot restore from secret storage until device verification is complete.
    • What to do: run
      text
      printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify device --recovery-key-stdin
      first.

    Custom plugin install messages

    text
    Matrix is installed from a custom path that no longer exists: ...

    • Meaning: your plugin install record points at a local path that is gone.
    • What to do: reinstall with
      text
      openclaw plugins install @openclaw/matrix
      , or if you are running from a repo checkout,
      text
      openclaw plugins install ./path/to/local/matrix-plugin
      .
    • If npm reports the OpenClaw-owned Matrix package as deprecated, use the bundled plugin from a current packaged OpenClaw build or the local checkout path until a newer npm package is published.

    If encrypted history still does not come back

    Run these checks in order:

    bash
    openclaw matrix verify status --verbose openclaw matrix verify backup status --verbose printf '%s\n' "$MATRIX_RECOVERY_KEY" | openclaw matrix verify backup restore --recovery-key-stdin --verbose

    If the backup restores successfully but some old rooms are still missing history, those missing keys were probably never backed up by the previous plugin.

    If you want to start fresh for future messages

    If you accept losing unrecoverable old encrypted history and only want a clean backup baseline going forward, run these commands in order:

    bash
    openclaw matrix verify backup reset --yes openclaw matrix verify backup status --verbose openclaw matrix verify status

    If the device is still unverified after that, finish verification from your Matrix client by comparing the SAS emoji or decimal codes and confirming that they match.

    Related

    • Matrix: channel setup and config.
    • Matrix push rules: notification routing.
    • Doctor: health check and automatic migration trigger.
    • Migration guide: all migration paths (machine moves, cross-system imports).
    • Plugins: plugin install and registration.

    © 2024 TaskFlow Mirror

    Powered by TaskFlow Sync Engine