neoagent 2.4.4-beta.8 → 2.5.0

package/docs/getting-started.md

@@ -1,89 +1,79 @@
-# Getting Started
+# Installation
 
-Install takes about 5 minutes. The first VM boot downloads and configures an Ubuntu guest image, which adds a few more minutes on first run.
+NeoAgent supports macOS and Linux hosts. It installs as a long-running service,
+so use a machine that remains online when you expect automations, messaging, or
+remote access to work.
 
 ## Requirements
 
-| | |
-|---|---|
-| Node.js | 20 or newer |
-| QEMU | installed automatically when supported; used for VM-isolated browser and Android |
-| AI provider key | Anthropic, OpenAI, Gemini, Grok, MiniMax, or local Ollama |
+- Node.js 20 or newer with npm
+- A macOS or Linux user account that can install packages
+- Enough disk and memory for the models and runtime you choose
+- QEMU for the isolated browser and terminal runtime
 
-No API key is required if you only use local Ollama.
-
-### Optional manual QEMU install
-
-`neoagent install` tries to install QEMU on supported macOS and Linux package
-managers. If the machine does not have a supported package manager yet, install
-QEMU manually and rerun `neoagent install`.
+The installer attempts to install QEMU with Homebrew, `apt`, `dnf`, or `yum`.
+If the host uses another package manager, install QEMU first.
 
 ```bash
 # macOS
 brew install qemu
 
-# Ubuntu / Debian
-sudo apt-get update && sudo apt-get install -y qemu-system qemu-utils
+# Ubuntu or Debian
+sudo apt-get update
+sudo apt-get install -y qemu-system qemu-utils
 ```
 
-## Install
+## Install NeoAgent
 
 ```bash
 npm install -g neoagent
 neoagent install
 ```
 
-This runs a preflight, creates or updates config, installs dependencies, builds
-or uses the bundled web client, starts the service, and prints any remaining
-machine-specific action items.
-
-Open **http://localhost:3333** in your browser when the install finishes.
+`neoagent install` checks the host, creates the runtime configuration, installs
+application dependencies and supported system tools, prepares the isolated
+runtime, and registers a launchd or systemd user service when available.
 
-## First Run
+Read the post-install actions printed by the command. They describe anything
+the installer could not complete automatically.
 
-1. Create an account.
-2. Open **Settings → AI Providers** and add at least one API key.
-3. Send a message in **Chat** to confirm the agent responds.
+Open `http://localhost:3333` on the server. For remote access, configure HTTPS
+and `PUBLIC_URL` before connecting integrations or mobile clients.
 
-Everything else — integrations, messaging, tasks, Android control — is configured inside the app.
+## First run
 
-## Service Commands
-
-```bash
-neoagent status      # check install root, config path, and service state
-neoagent start
-neoagent stop
-neoagent restart
-neoagent logs        # first stop when something behaves unexpectedly
-```
+1. Create the first user account.
+2. Open **Settings > AI Providers**.
+3. Configure a hosted provider or connect local Ollama.
+4. Select a model and send a message in **Chat**.
+5. Open **Settings > Tool Permissions** and review the approval policy before
+   enabling browser, shell, file-write, desktop, or Android actions.
 
-## Re-running Setup
+The first isolated-runtime boot downloads and prepares an Ubuntu image. It can
+take several minutes and is not required for a basic model-only chat.
 
-Run this to regenerate config or change provider keys:
+## Check the installation
 
 ```bash
-neoagent setup
+neoagent status
+neoagent logs
 ```
 
-The wizard prompts for port, public URL, release channel, AI keys, Ollama URL, and OAuth credentials.
-
-## Updates and Recovery
-
-```bash
-neoagent channel stable   # switch to stable releases
-neoagent channel beta     # switch to prerelease builds
-neoagent update           # update to latest on the current channel
-neoagent fix              # reset after a broken install or self-edit
-```
+`status` reports the install path, configuration, release channel, service
+state, and server health. Use `logs` on the machine running NeoAgent; logs from
+another computer do not describe the remote server.
 
-`neoagent fix` backs up runtime data, resets source files, reinstalls dependencies, and restarts the service. Use it when `neoagent setup && neoagent restart` hasn't resolved an issue.
+## Global npm permission errors
 
-## Runtime Paths
+If `npm install -g` fails with `EACCES` on macOS, install Node through
+[nvm](https://github.com/nvm-sh/nvm) so global packages live in your user
+directory. Running the npm command with `sudo` also works, but makes later
+package ownership harder to manage.
 
-| Path | Contents |
-|---|---|
-| `~/.neoagent/.env` | Server config and secrets |
-| `~/.neoagent/data/` | Database, session data, logs |
-| `~/.neoagent/agent-data/` | Skills, memory, daily data |
+## Next steps
 
-Set `NEOAGENT_HOME` to move the runtime root.
+- [Configure models](models.md)
+- [Create specialist agents](agents-and-users.md)
+- [Connect accounts and messaging](integrations.md)
+- [Set up automation](automation.md)
+- [Review deployment security](security-boundaries.md)

package/docs/index.md

@@ -1,49 +1,60 @@
 ---
 slug: /
-title: NeoAgent
+title: NeoAgent documentation
 sidebar_label: Overview
 ---
 
-<p align="center">
-  <img src="/img/app_icon.png" width="72" alt="NeoAgent" />
-</p>
+# NeoAgent documentation
 
-# NeoAgent
+NeoAgent is a self-hosted AI agent that runs continuously on a macOS or Linux
+server. It provides an operator interface for chat, automation, integrations,
+memory, recordings, and connected devices.
 
-Self-hosted AI agent server. Runs as a system service, keeps all credentials on your machine, and provides a full operator UI for chat, automation, Android device control, recordings, integrations, and memory.
+NeoAgent is beta software. Install it on a machine you administer, start with
+restricted tool permissions, and read the security guide before connecting
+sensitive accounts.
 
-## Quick Start
+## 🚀 Start here
 
 ```bash
 npm install -g neoagent
 neoagent install
 ```
 
-Opens at `http://localhost:3333` when complete. See [Getting Started](getting-started.md) for prerequisites and first-run steps.
+The installer starts the service and prints any host-specific action items.
+Open `http://localhost:3333` when it finishes.
 
-## What You Can Do
+Continue with:
 
-| | |
-|---|---|
-| **Chat with tools** | Browse the web, run shell commands, read/write files, call APIs, generate images |
-| **Automate** | Schedule tasks on cron, trigger from integrations or weather events, deliver results via messaging |
-| **Control Android** | Screenshot, observe UI, tap, type, swipe, launch apps, install APKs, run `adb shell` |
-| **Connect accounts** | Google Workspace, Microsoft 365, Notion, Slack, Figma, Home Assistant, Trello, Spotify |
-| **Message anywhere** | Telegram, WhatsApp, Discord, Signal, Matrix, iMessage, Teams, Telnyx Voice, and more |
-| **Record and transcribe** | Audio sessions from browser or Android, transcript search, AI-generated insights |
-| **Remember** | Long-term semantic memory, session logs, core facts, daily summaries |
+- [Install and complete the first run](getting-started.md)
+- [Choose and configure a model](models.md)
+- [Understand the security boundaries](security-boundaries.md)
+- [Migrate from OpenClaw or Hermes](migration.md)
 
-## Documentation
+## 🧭 User guide
 
-| | |
+| Guide | Use it for |
 |---|---|
-| [Getting Started](getting-started.md) | Install, first run, service commands |
-| [Capabilities](capabilities.md) | Full tool and feature inventory |
-| [Configuration](configuration.md) | Environment variables, provider keys, OAuth setup |
-| [Security Boundaries](security-boundaries.md) | Enforced isolation, prompt-injection limits, deployment guidance |
-| [Automation](automation.md) | Tasks, cron scheduling, integration triggers |
-| [Integrations](integrations.md) | OAuth accounts and messaging platforms |
-| [Skills](skills.md) | Built-in skills catalog, custom skills, MCP |
-| [Operations](operations.md) | Updates, logs, recovery |
-| [Why NeoAgent](why-neoagent.md) | Comparison with OpenClaw |
-| [Migration](migration.md) | Migrate from OpenClaw or Hermes |
+| [Installation](getting-started.md) | Host requirements, installation, first run |
+| [Models](models.md) | Local, API-key, and account-backed model providers |
+| [Agents and users](agents-and-users.md) | Specialist agents and multi-user administration |
+| [Automation](automation.md) | Schedules, event triggers, delivery, and run history |
+| [Memory](memory.md) | What NeoAgent remembers and how to manage it |
+| [Integrations](integrations.md) | Connected app accounts and messaging channels |
+| [Devices and interfaces](devices.md) | Android, desktop, Chrome, launcher, and wearable surfaces |
+| [Recordings and health](recordings-and-health.md) | Audio transcription and Health Connect |
+| [Skills and MCP](skills.md) | Reusable instructions and external tool servers |
+| [Operations](operations.md) | Updates, backups, logs, and recovery |
+| [Configuration](configuration.md) | Environment and runtime reference |
+| [Why NeoAgent](why-neoagent.md) | Factual comparison with OpenClaw and Hermes |
+
+## 🛠️ Developer guide
+
+The developer guide explains the implementation rather than the product setup.
+Start with [Architecture](architecture.md), then follow the subsystem links in
+the developer section of the sidebar.
+
+Contributors must also follow
+[GUIDELINES.md](https://github.com/NeoLabs-Systems/NeoAgent/blob/main/GUIDELINES.md)
+and
+[CONTRIBUTING.md](https://github.com/NeoLabs-Systems/NeoAgent/blob/main/CONTRIBUTING.md).

package/docs/integrations-architecture.md

@@ -0,0 +1,48 @@
+# Integrations and messaging architecture
+
+Official integrations and messaging channels are separate service families.
+They can expose the same external product while using different credentials
+and data paths.
+
+## Integration registry
+
+The integration registry loads provider implementations. A provider describes
+its applications, environment readiness, connection flow, tool definitions,
+access modes, and optional memory-ingestion support.
+
+OAuth state is short-lived and server-stored. Connection credentials are
+encrypted before they are written to SQLite. Refresh responses are merged with
+existing credentials so providers that omit a new refresh token do not erase
+the durable token.
+
+Connections are scoped by user, agent, provider, and account. Read-only access
+is enforced when the integration tool is executed, not through prompt wording.
+
+## Tool execution
+
+Integration tools join the agent tool catalog when the owning agent has a
+usable connection. The integration manager resolves the connection, refreshes
+credentials when required, enforces access mode, invokes the provider, and
+persists updated credentials.
+
+## Memory ingestion
+
+Providers that support background memory expose source collectors. The
+ingestion service creates durable jobs, fetches changed source objects, stores
+source documents, chunks content, and links extracted memory back to those
+chunks.
+
+Provider snapshots shown in the client are decorated with ingestion coverage
+and status.
+
+## Messaging
+
+Messaging providers are long-running channel adapters managed separately from
+official integrations. They normalize inbound messages, enforce chat and
+sender allowlists, create agent runs, send typing state, and deliver outbound
+messages.
+
+Webhook-backed channels enter through shared HTTP routes. Native adapters can
+maintain sockets, polling loops, or provider-specific sessions. Personal
+WhatsApp integration credentials remain separate from the WhatsApp messaging
+bridge.

package/docs/integrations.md

@@ -1,66 +1,71 @@
-# Integrations
+# Integrations and messaging
 
-NeoAgent has two integration layers: official integrations for structured app tools, and messaging platforms for communicating with the agent.
+NeoAgent has two connection layers with different purposes.
 
-## Official Integrations
+**Integrations** give the agent structured tools for an account. **Messaging
+channels** let people talk to the agent and receive automation results.
+Connecting Slack or WhatsApp in one layer does not automatically configure the
+other.
 
-Structured OAuth-backed tools the agent can use in chat and automation. Connect accounts in the Flutter app under **Integrations**.
+## Official integrations
 
-| Provider | What the agent can do |
+Connect accounts in **Integrations**.
+
+| Provider | Available areas |
 |---|---|
-| **Google Workspace** | Search and send Gmail, read/create Calendar events, Drive upload/download/share, Docs create/append, Sheets read/write |
-| **Microsoft 365** | Outlook mail, Calendar, OneDrive, Teams messages, Graph API |
-| **Notion** | Search pages, read/write databases and blocks, manage comments |
-| **Slack** | Read and send messages, search conversations |
-| **Figma** | Read files and nodes, get rendered images, manage comments |
-| **Home Assistant** | Read entity state, call services |
-| **Trello** | Manage boards, lists, cards, comments, and search |
-| **Spotify** | Playback controls, search, queue management |
-| **Weather** | Current conditions and forecasts — no API key needed |
-| **Personal WhatsApp** | Per-account read and send with isolated access |
+| Google Workspace | Gmail, Calendar, Drive, Docs, Sheets |
+| Microsoft 365 | Outlook, Calendar, OneDrive, Teams |
+| GitHub | Repositories, issues, pull requests, files, branches, workflows |
+| Notion | Pages, databases, blocks, search |
+| Slack | Conversations, history, search, messages |
+| Figma | Files, nodes, rendered images, comments |
+| Home Assistant | Entity state and service calls |
+| Trello | Boards, lists, cards, comments, search |
+| Spotify | Playback, history, search, queue |
+| Weather | Location search, current conditions, forecasts |
+| Personal WhatsApp | Private account chat history and send tools |
 
-### Access Modes
+Available operations are discovered from the current server implementation and
+connected account. They may differ by provider permissions.
 
-Each connected account can be set to **Read/Write** (default) or **Read Only**. Read-only blocks all write operations server-side — sending, creating, updating, and deleting.
+### Read-only accounts
 
-### OAuth Setup
+Connected accounts can be set to **Read Only**. NeoAgent blocks their write
+tools server-side. Use read-only mode unless an agent must create, send, update,
+or delete data.
 
-Most providers require OAuth app credentials in server config before users can connect. See [Configuration: Official Integrations](configuration.md#official-integrations) for the required environment variables.
+### Setup
 
-Home Assistant and Trello can be configured per-user in the **Integrations** UI without any server-side setup.
+Google, Microsoft, GitHub, Notion, Slack, Figma, and Spotify require OAuth
+application credentials on the server. The default callback is:
 
-The default OAuth callback URL is `PUBLIC_URL + /api/integrations/oauth/callback`.
+```text
+PUBLIC_URL/api/integrations/oauth/callback
+```
 
-**If an OAuth connection fails:**
-1. Confirm `PUBLIC_URL` is reachable by the provider
-2. Confirm the redirect URI in your OAuth app matches NeoAgent's callback URL
-3. Confirm the client ID and secret are set in server config
-4. Restart after changing environment variables: `neoagent restart`
+Home Assistant and Trello can be configured for a user from the application.
+See [Configuration](configuration.md#official-integrations).
 
-## Messaging Platforms
+## Messaging channels
 
-Channels through which users and the agent communicate. Configure credentials in the Flutter app under **Settings → Messaging** — not in `.env`.
+Configure messaging under **Settings > Messaging**. Supported bridges include
+WhatsApp, Telegram, Discord, Slack, Google Chat, Teams, Matrix, Signal,
+iMessage through BlueBubbles, IRC, Twitch, LINE, Mattermost, Telnyx Voice, and
+several webhook-backed services.
 
-| Platform | Notes |
-|---|---|
-| **WhatsApp** | Messaging bridge for agent chat; separate official integration for structured read/send tools |
-| **Telegram** | Bot token plus approved chat IDs |
-| **Discord** | Bot token plus server or channel access |
-| **Slack** | Bot token sends, Events API callbacks |
-| **Google Chat** | Space webhook sends, app callback ingestion |
-| **Microsoft Teams** | Incoming webhook sends, outgoing webhook ingestion |
-| **Matrix** | Homeserver access token, room send, polling |
-| **Signal** | signal-cli REST API bridge |
-| **iMessage / BlueBubbles** | BlueBubbles-compatible bridge on a macOS host |
-| **IRC and Twitch** | IRC-style channel connections |
-| **LINE and Mattermost** | Native send, webhook ingestion |
-| **Telnyx Voice** | Inbound and outbound calls with text-to-speech |
-| **Webhook bridges** | Feishu, Nextcloud Talk, Nostr, Synology Chat, Tlon, Zalo, WeChat, WebChat |
-
-Inbound webhook path: `PUBLIC_URL + /api/messaging/webhook/:platform`
-
-`TELNYX_WEBHOOK_TOKEN` is the only messaging credential that goes in `.env` — all others are configured through the app messaging tab.
-
-## Security
-
-Keep OAuth client secrets, bot tokens, and API keys on the server. Don't put them in skill files, task prompts, screenshots, or logs. Rotate immediately if a credential is exposed.
+Each channel has its own authentication and allowlist behavior. Restrict which
+chats, rooms, groups, and senders may start agent runs.
+
+Webhook-based channels require a reachable `PUBLIC_URL`. The generic inbound
+path is:
+
+```text
+PUBLIC_URL/api/messaging/webhook/:platform
+```
+
+## Troubleshooting
+
+For failed OAuth connections, confirm the public URL, callback, client
+credentials, and provider scopes. For messaging failures, inspect **Runs** and
+server logs on the NeoAgent host, then verify the channel allowlist and webhook
+reachability.

package/docs/memory-architecture.md

@@ -0,0 +1,90 @@
+# Memory architecture
+
+NeoAgent memory separates source material, readable memories, structured
+facts, and retrieval telemetry. The design keeps current facts useful while
+retaining provenance and history.
+
+## Data model
+
+### Memories
+
+`memories` stores the readable unit used for recall. Each row is scoped by user
+and agent and includes category, source reference, importance, confidence,
+summary, embedding metadata, archive state, and timestamps.
+
+### Facts and relations
+
+`memory_facts` stores atomic subject-predicate-object facts. Facts can have
+event time, validity bounds, learned time, status, and a superseded fact ID.
+
+`memory_relations` links memories with:
+
+- `updates` for replacement;
+- `extends` for compatible additional detail; and
+- `derives` for supported inference.
+
+When a new fact conflicts with an active fact for the same subject and
+predicate, the previous fact is superseded unless the new fact is an extension
+or derivation. External-source conflicts with stable or high-confidence facts
+can be held for review.
+
+### Sources and provenance
+
+Integration ingestion stores source documents separately from memory.
+Documents are split into position-aware chunks. `memory_source_links` connects
+an extracted memory to its source chunk and document.
+
+This keeps source evidence available without injecting complete documents into
+every prompt.
+
+## Ingestion
+
+Conversation consolidation is a structured model pass after the run. It
+extracts a bounded list of durable candidates and excludes secrets, routine
+tool output, unsupported guesses, and thread-only details.
+
+Integration ingestion runs through durable jobs with source cursors and
+freshness metadata. Chunk extraction attempts are tracked so failed work can be
+retried without treating incomplete content as processed.
+
+## Retrieval
+
+The local candidate stage combines:
+
+- Approximate semantic candidates from embedding bands
+- SQLite full-text and lexical matches
+- Entity mentions
+- Memory relations
+- Importance, confidence, freshness, and access signals
+
+Superseded and expired facts are excluded from normal current recall. Selected
+results can include a bounded version-history note and source location.
+
+When the top result is missing, weak, or ambiguous, the AI engine can generate
+query variants and temporal intent, merge the resulting candidates, and rerank
+only those candidates. Confident retrieval avoids this additional model call.
+
+Retrieval events record candidate counts, result IDs, estimated context size,
+and latency. Enhancement events record why planning was used and which results
+survived.
+
+## Prompt context
+
+Memory reaches the model through three bounded paths:
+
+1. Core memory for explicit always-relevant values
+2. An auto-maintained static and dynamic profile built from active facts
+3. Query-specific recalled memories
+
+All paths are scoped to the selected user and agent. Subagents receive the
+agent scope supplied by their parent run.
+
+## Privacy and trust
+
+Memory remains in NeoAgent storage, but hosted models and embedding providers
+receive the text sent to them. External source content is marked as untrusted
+data in recalled context.
+
+Memory quality claims require reproducible evaluation. The repository includes
+retrieval evaluation and benchmark tooling, but the documentation does not
+claim parity or superiority based on architecture alone.

package/docs/memory.md

@@ -0,0 +1,78 @@
+# Memory
+
+NeoAgent keeps useful context across conversations without treating the entire
+chat transcript as permanent memory. Memory data is stored by the NeoAgent
+server and scoped to a user and agent.
+
+## What gets remembered
+
+After a conversation, the model can extract durable information such as:
+
+- Identity and stable preferences
+- Ongoing projects and responsibilities
+- Important contacts and relationships
+- Events with meaningful dates
+- Current context that will matter in a later conversation
+
+Routine tool output, credentials, guesses, and one-off task narration should
+not become long-term memory. The agent can also save an explicit fact with its
+memory tool when a conversation requires it.
+
+## Structured facts
+
+A saved memory contains readable text plus structured facts. A fact records a
+subject, relationship, value, category, confidence, and optional time bounds.
+New information can:
+
+- update and supersede an older fact;
+- extend an existing fact with compatible detail; or
+- record a supported inference at lower confidence.
+
+Normal recall favors active facts and excludes superseded or expired facts.
+Historical queries can still use version context when it is relevant.
+
+## Retrieval
+
+NeoAgent combines several local signals:
+
+- Semantic similarity when embeddings are configured
+- SQLite full-text and lexical matching
+- Entity matches
+- Fact relationships and current-version status
+- Importance, confidence, freshness, and prior use
+
+Confident results use this local fast path. Ambiguous retrieval can ask the
+configured model to reformulate the search and rerank known candidates. The
+model does not receive unrestricted access to the database.
+
+Stable facts and current context also form a bounded user profile that is
+available to the owning agent even when a narrow search would not retrieve it.
+
+## Integration memory
+
+Supported integrations can ingest source documents in the background. Source
+content is chunked, indexed, and linked to extracted memories so recalled
+context can retain provenance.
+
+External source text is treated as data rather than instructions. Conflicts
+with high-confidence or stable memories may require review instead of silently
+replacing the existing fact.
+
+## Manage memory
+
+Open **Memory** to search and inspect stored items. NeoAgent supports editing,
+archiving, bulk deletion, permanent deletion, core-memory management, and
+conversation search.
+
+Deleting a conversation is not the same as deleting extracted memory. Review
+both areas when removing personal information.
+
+## Storage and privacy
+
+Memory is stored in NeoAgent's SQLite database and runtime data directories.
+It is not sent to an external memory service. Content still leaves the server
+when a hosted model or hosted embedding provider is used to process it.
+
+Back up `~/.neoagent/data/` and `~/.neoagent/agent-data/` together. See
+[Memory architecture](memory-architecture.md) for the implementation and
+[Operations](operations.md) for backup guidance.

package/docs/migration.md

@@ -6,7 +6,9 @@ sidebar_label: Migration
 
 # Migration Guide
 
-Migrate your existing agent setup from OpenClaw or Hermes to NeoAgent with a single command.
+NeoAgent can copy supported files and selected configuration from a default
+OpenClaw or Hermes installation. Run a dry run first and review imported
+content before using it with an agent.
 
 ## Quick Start
 
@@ -16,12 +18,12 @@ neoagent migrate dry-run   # preview what would be migrated
 neoagent migrate status    # check what's detected
 ```
 
-## What Gets Migrated
+## What gets migrated
 
 | Data | OpenClaw source | Hermes source | Destination |
 |---|---|---|---|
 | Skills | `~/.openclaw/skills/*.md` | `~/.hermes/skills/*.md` | `~/.neoagent/agent-data/skills/openclaw-imports/` or `hermes-imports/` |
-| Memory | `SOUL.md`, `MEMORY.md`, `USER.md` | `MEMORY.md`, `USER.md` | `~/.neoagent/agent-data/memory/openclaw/` or `hermes/` |
+| Memory files | `SOUL.md`, `MEMORY.md`, `USER.md` | `MEMORY.md`, `USER.md` | `~/.neoagent/agent-data/memory/openclaw/` or `hermes/` |
 | API keys | from `.env` | from `.env` | merged into `~/.neoagent/.env` |
 
 ## Prerequisites
@@ -113,13 +115,18 @@ Choice [1]:
 
 `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `XAI_API_KEY`, `GOOGLE_AI_KEY`, `MINIMAX_API_KEY`, `BRAVE_SEARCH_API_KEY`, `DEEPGRAM_API_KEY`, `TELEGRAM_BOT_TOKEN`, `OPENROUTER_API_KEY`, `ELEVENLABS_API_KEY`, `SLACK_BOT_TOKEN`, `DISCORD_BOT_TOKEN`
 
-## Post-Migration Steps
+Imported Markdown is preserved as source material. Copying it does not turn
+every line into a verified structured memory fact. Review it for stale,
+conflicting, or sensitive information.
+
+## Post-migration steps
 
 1. `neoagent status` — verify the installation
 2. `neoagent start` — start the server
 3. Review imported skills in `~/.neoagent/agent-data/skills/openclaw-imports/` and `hermes-imports/`
 4. Review imported memory in `~/.neoagent/agent-data/memory/`
-5. Reconfigure messaging channels in the NeoAgent UI if you had Telegram or Discord set up
+5. Reconfigure messaging channels and official integrations in the NeoAgent UI
+6. Test recall with non-sensitive facts before relying on imported memory
 
 ## Troubleshooting