--- name: atlas-scout description: > Install, configure, and use Atlas Scout - a local, read-only MCP code-navigation server that gives coding agents a structural map of a repository: definitions, references, call graphs, edit impact, and exact source ranges in single bounded tool calls, instead of repeated text searches and file dumps. --- # Atlas Scout: install and use You are an AI coding agent. This skill teaches you to install Atlas Scout on the machine you are working on, connect it to your MCP host, and use it as your primary navigation path for structural code questions. Atlas Scout is local and read-only. It never uploads repository content and never executes project code. Its index is one generated SQLite database per workspace at `.atlas/scout/symbols.db` - Scout gitignores it automatically on first open, and every local client (agents, CLI, editors) shares it. Free requires no account, key, or network. Releases are distributed as an unsigned technical preview from `https://download.atlasscout.dev`. Scout maps code that already exists: an empty or nearly-empty workspace yields an empty index with nothing to look up. Expect its value to begin once the repository has source files to map, and to grow with them. ## 1. Install (Linux and macOS) Download and run the official installer. It resolves the latest preview release from `https://download.atlasscout.dev/preview/latest.json`, detects the OS and architecture (Linux x86-64/ARM64, macOS Apple Silicon), verifies the artifact's SHA-256 checksum plus the OpenPGP signature over `SHA256SUMS` when `gpg` is available, and installs the complete release. By default, immutable release trees live under `~/.local/share/atlas-scout/releases`, `~/.local/share/atlas-scout/current` selects the active release, and `~/.local/bin/atlas-scout` plus `atlas-scoutd` are stable links through that pointer: ```sh curl -fsSL https://atlasscout.dev/install.sh -o /tmp/atlas-scout-install.sh sh /tmp/atlas-scout-install.sh ``` Options via environment variables: - `ATLAS_SCOUT_VERSION=` - install an explicitly requested release (default: `latest.json`). - `ATLAS_SCOUT_DATA_DIR=` - use another managed release root. - `XDG_DATA_HOME=` - changes the default root to `$XDG_DATA_HOME/atlas-scout`. - `ATLAS_SCOUT_BIN_DIR=` - put the stable executable links somewhere else. - `ATLAS_SCOUT_INSTALL_DIR=` - deprecated alias for `ATLAS_SCOUT_BIN_DIR`. - `ATLAS_SCOUT_CLAUDE_PLUGIN=ask|install|skip` - control persistent Claude user-scope setup. An interactive install offers persistent Claude setup when `claude` is available. For an initial non-interactive install, ask first; with approval, run `ATLAS_SCOUT_CLAUDE_PLUGIN=install sh /tmp/atlas-scout-install.sh`, or set `skip` if declined. Do not modify Claude configuration without that initial approval. Later runs may refresh an installed plugin. Interactively, the installer asks before downloading the unsigned preview. Non-interactively, it prints the notice and continues; relay it to the user. If a download fails, stop. Do not try other sources. The installer prints the resolved command and plugin paths. It checks that the link directory is on `PATH` and not shadowed by an earlier `atlas-scout`. If that fails, do not report setup complete. Use absolute paths for verification, and ask before editing a shell profile. For one session: ```sh export PATH="$HOME/.local/bin:$PATH" ``` Never silently edit `.profile`, `.bashrc`, `.zshrc`, or shell-framework configuration. Use the installer's actual path when the user selected a different link directory. **Windows** (x86-64): there is no scripted installer yet. Download `atlas-scout--x86_64-pc-windows-msvc.zip` from the release directory referenced by `latest.json`, verify its SHA-256 against `SHA256SUMS` from the same directory (`Get-FileHash` in PowerShell), extract it, and put the folder on PATH. If SmartScreen or Smart App Control blocks it, stop and tell the user - see https://atlasscout.dev/docs#preview. Preview binaries are unsigned (no Apple/Microsoft publisher signature yet). The curl-and-tar path above normally avoids macOS quarantine, but this is not guaranteed - Gatekeeper's exact behavior is undocumented and can change. If Gatekeeper (or any OS/endpoint protection) blocks the binary: STOP and tell the user. Never remove quarantine attributes (`xattr -d com.apple.quarantine` is forbidden), never bypass Gatekeeper, SmartScreen, antivirus, or an organization policy on the user's behalf. Per-file exceptions are the user's decision to make by hand, and only for artifacts they have verified - see https://atlasscout.dev/docs#preview. Verify the installation: ```sh atlas-scout --version ``` ## 2. Index the project ```sh atlas-scout index /absolute/path/to/project atlas-scout doctor --workspace /absolute/path/to/project ``` Indexing takes seconds on most repositories and is optional pre-warming - MCP initialization never waits for a repository walk. `doctor` prints the resolved workspace, index location, language coverage, and host-specific setup snippets. The index is generated state at `.atlas/scout/symbols.db`: never commit it, and for read-only checkouts or CI use `--cache-dir` / `ATLAS_SCOUT_CACHE_DIR` (all sharing clients need the same override). If a workspace is moved or copied together with `.atlas`, Scout validates the old workspace identity, preserves the complete generated cache as `.atlas/scout.relocated-`, and creates a fresh index for the new canonical location. It never rewrites or reuses the old SQLite/WAL state. `atlas-scout doctor` lists preserved archives; they remain ignored generated data until the user chooses to remove them. Malformed identity data, symlinks, rename failures, and explicit external-cache collisions remain hard errors - do not delete or rewrite that state as an automatic workaround. ## 3. Register with the MCP host Use the absolute path to the installed binary. Do not add a fixed `--workspace` argument for user-level registrations: Atlas Scout selects the active project from `ATLAS_SCOUT_WORKSPACE`, then `CLAUDE_PROJECT_DIR`, then the MCP process working directory. Codex plugin: Atlas Scout is published in OpenAI's universal Plugins Directory at . Obtain approval before installing it. The directory entry provides the code-navigation and guarded-setup skills only; it does not install the proprietary runtime or create the local MCP connection. After the runtime is installed and verified, users who do not already have a manual Atlas Scout MCP registration can install the MCP-enabled public plugin: ```sh codex plugin marketplace add ZaguanLabs/atlas-scout-codex-plugin codex plugin add atlas-scout@atlas-scout ``` Start a new Codex thread afterward. If a manual `atlas-scout` MCP server is already registered, either keep it and leave the MCP-enabled plugin uninstalled, or remove the manual registration before enabling the plugin. Never configure both paths to start the server in one Codex environment. The inspectable Apache-2.0 wrapper is at ; the local runtime remains separately licensed proprietary software. Claude Code plugin (preferred): with approval, the installer persistently installs `atlas-scout@atlas-scout-local` at user scope. Verify with `claude plugin list --json`, then start a new Claude session. If setup was skipped, use the printed marketplace path: ```sh claude plugin marketplace add \ "$HOME/.local/share/atlas-scout/claude-code-marketplace" \ --scope user claude plugin install atlas-scout@atlas-scout-local --scope user ``` Substitute a custom path as printed. Obtain approval first; these commands change Claude's user configuration. `claude --plugin-dir` is only a one-session sideload, never an installation. The inspectable Apache-2.0 plugin wrapper is also public at . Its Anthropic community-directory submission is currently under review, so do not use or recommend an official-directory install yet. Users who prefer the public GitHub marketplace source can choose it instead of the managed local marketplace: ```sh claude plugin marketplace add ZaguanLabs/atlas-scout-claude-plugin --scope user claude plugin install atlas-scout@atlas-scout --scope user ``` Obtain approval first and choose one plugin source, not both. The public wrapper configures the already-installed local runtime; it does not install Atlas Scout, run repository code, inspect conversation history, or send source code to Zaguán Labs. The proprietary runtime remains separate from the Apache-2.0 wrapper. The plugin invokes `atlas-scout` by name, so its link directory must be on Claude's `PATH`. For one session: ```sh export PATH="$HOME/.local/bin:$PATH" claude ``` The plugin owns the MCP registration. Remove or disable a duplicate manually registered `atlas-scout` server while it is active. It keeps the five most useful entry points eager when the current edition includes them: `symbol_search`, `symbol_outline`, `symbol_references`, `fast_context`, and `edit_impact`. Entitlement filtering happens first, so Free exposes its three included entry points and Pro can expose all five; other tools remain available on demand. The plugin injects advisory navigation context at `SessionStart` and `SubagentStart`. A narrow `PreToolUse` hook may also return Scout context for a Claude `Grep` call whose pattern is a bare code identifier containing an underscore or capital letter. It runs at most twice per session, returns context only, and makes no permission decision. Prose searches, regular expressions, and every other tool call are ignored. The hooks never inspect conversation history, deny, retry, or modify a tool call. The plugin invokes `atlas-scout claude-code hook ` for these events. Claude Code manual MCP mode (user scope, available in every project): ```sh claude mcp add --scope user --transport stdio atlas-scout -- \ "$HOME/.local/bin/atlas-scout" mcp ``` Codex: ```sh codex mcp add atlas-scout -- "$HOME/.local/bin/atlas-scout" mcp ``` Any other MCP host (JSON configuration): ```json { "mcpServers": { "atlas-scout": { "command": "/absolute/path/to/atlas-scout", "args": ["mcp"] } } } ``` Devin: once Atlas Scout is registered and active, enable the **Disable fast context agent** toggle in Devin's settings ("Stops the fast context agent from running parallel searches as a subagent"). The fast context agent duplicates the navigation work Scout already answers from its index; disabling it removes the competing parallel searches and leaves Scout as the single navigation path. Start a new session after registering - MCP servers are discovered at session start. In manual Claude Code mode, the same entitlement-aware loading metadata keeps `symbol_search`, `symbol_outline`, and `symbol_references` visible for Free; Pro also keeps `fast_context` and `edit_impact` visible. Other tools are deferred. Manual mode does not add the plugin hooks. No prompt command is required for normal use. For diagnosis, `/mcp__atlas-scout__atlas_scout_symbols_workflow` injects the canonical workflow. `/mcp__atlas-scout__atlas_scout_task_recipes` adds compact recipes for feature consolidation, UI-consumer discovery, and display-to-mutation tracing. For an opt-in stronger instruction that preserves Claude Code's default safety prompt: ```sh claude --append-system-prompt "$(atlas-scout claude-code print-system-prompt)" ``` For non-interactive runs, explicitly allow the read-only MCP namespace; `dontAsk` otherwise denies Scout calls and encourages built-in-tool fallback: ```sh claude -p "" --allowedTools 'mcp__atlas-scout__*' ``` ### Host timeouts on large repositories Normal MCP initialization is bounded even when an existing workspace database is large. On a cold repository, however, the first tool call that needs index work can still exceed a host's default tool timeout - as a reference point, a full Firefox checkout (~470,000 files) takes on the order of minutes to index cold, while most projects take seconds. If a tool call fails with a host-side timeout, do not conclude Atlas Scout is broken. Fix it in this order: 1. Pre-warm from the shell (no MCP timeout applies there): `atlas-scout index /absolute/path/to/project`. 2. Raise the host's tool timeout. If MCP initialization itself times out, also inspect the host configuration and process state before changing its startup timeout. The right value depends on the project size - this is the user's decision; suggest a value, don't assume. - **Codex** (`~/.codex/config.toml`, per server; defaults are `startup_timeout_sec` 10 and `tool_timeout_sec` 60): ```toml [mcp_servers.atlas-scout] command = "/absolute/path/to/atlas-scout" args = ["mcp"] startup_timeout_sec = 10 tool_timeout_sec = 300 ``` - **Claude Code**: set `MCP_TOOL_TIMEOUT` in milliseconds - e.g. `MCP_TOOL_TIMEOUT=300000 claude`. Change the separate `MCP_TIMEOUT` server-startup value only when initialization itself fails. - Other hosts: check their MCP server settings for the equivalent tool timeout knob, and startup timeout only when initialization itself fails. 300 seconds is a generous ceiling that covers even Firefox-sized cold indexing on an ordinary workstation; smaller repositories need far less. ### Connection compatibility Some MCP clients probe `server/discover` before sending the supported `initialize` request. Atlas Scout deliberately answers that unsupported probe with the standard JSON-RPC `-32601 Method not found` response and keeps the same stdio connection open for normal initialization. Antigravity may also send `notifications/roots/list_changed` before initialization; Scout ignores that premature notification until the required `initialize` request arrives. No special host configuration is required. This applies to both direct `atlas-scout mcp` and daemon-backed sessions; it does not mean Scout implements `server/discover`, stateless MCP, or Streamable HTTP. ### Direct or daemon-backed MCP The host always launches `atlas-scout mcp`. It automatically uses a compatible local `atlas-scoutd` when one is available and falls back to its direct in-process server when one is not. Both modes share the same persistent `.atlas/scout/symbols.db`; the daemon never owns a second index and is not a remote MCP server. - Start direct when one or a few clients need saved-file navigation and the simplest lifecycle. Each client owns its in-memory session, so short-lived clients may repeat database-open and warm-up work. - Start `atlas-scoutd --idle-seconds 600` when several local clients, repeated short sessions, a large workspace, or unsaved editor buffers make a warm shared process useful. It adds a resident process, must restart after an upgrade, and its memory-only overlays disappear when it stops. The daemon accepts only the per-user local Unix socket or Windows named pipe. The Neovim and VS Code overlay clients are not yet publicly distributed. Use `atlas-scout doctor` to inspect daemon discovery, protocol compatibility, and direct fallback. ## 4. Teach the repository (recommended) Add this block to the project's `AGENTS.md` (or `CLAUDE.md`) so every future agent session prefers structural navigation over text-search spirals: ```markdown # Atlas Scout ## Code navigation When Atlas Scout MCP tools are available, use them as the primary navigation path for repository investigations that need the correct file, source range, or structural relationship: definitions, named symbols, unknown locations, callers, references, dependency paths, architecture, and edit impact. - If the file and range are already known, read that range directly. - If a file is known but the relevant range is not, use `symbol_outline` before reading the file. - If the location is unknown, use `symbol_search`, then `symbol_resolve` when exact metadata is needed. - Use `symbol_references`, `symbol_graph`, `symbol_trace`, `symbol_path`, or `edit_impact` for the corresponding structural question. - Read the exact source ranges returned by Atlas Scout before drawing conclusions or editing. - Use `rg` or other raw-text search for literals, regexes, unmodeled text, unsupported/partial language coverage, an explicit user request, or after focused Atlas Scout queries miss. Do not use shell text search as the default substitute for Atlas Scout when the task is structural code navigation. ``` ## 5. Using the tools Always free (six tools): `symbol_schema` (trust/coverage check), `symbol_search` (location unknown), `symbol_outline` (file known, range unknown), `symbol_resolve` (exact metadata for one ID), `symbol_references` (one-hop callers/callees/uses), `semantic_anchor_search` (routes, config keys, rationale, docs links - non-symbol evidence). Pro adds eight (evaluation, subscription, or fallback): `fast_context` (ranked task shortlist), `symbol_graph`, `symbol_related`, `symbol_trace`, `symbol_path`, `edit_impact`, `symbol_query`, `symbol_architecture`. The reliable workflow, in order: 1. Exact file and range known → read directly; skip Atlas Scout. 2. File known, range unknown → `symbol_outline`. 3. Location unknown → `symbol_search` with the strongest identifier. 4. `symbol_resolve` when exact metadata matters. 5. `symbol_references` for direct relationships. 6. Graph/trace/path/impact tools only for genuinely connected questions. 7. Read the returned ranges with your normal file tool before editing. 8. Fall back to text search for literals, generated text, or after focused queries miss. Every response is bounded. Routine healthy, fresh, non-empty, fully supported, complete results use an empty `_meta` object; absence of diagnostic fields is the nominal state. Empty, partial, indexing, stale, degraded, failed, shared-writer, truncated, or argument-repaired results retain the relevant trust evidence. Check that evidence before trusting broad or empty results (`symbol_schema` always returns the full health and language census). Atlas Scout returns coordinates and relationships, not file bodies: read the ranges it points to. Compact defaults are deliberate: `symbol_search` returns five ranked results, `symbol_outline` returns twenty top-level declarations, and `fast_context` returns a compact projection. Omit `limit` for the five-result search default. Leave `include_connected_evidence` omitted for location-only searches; enable it only when a small caller/callee preview is likely to replace another structural call. Search and outline already return stable IDs, paths, ranges, and signatures; use `symbol_resolve` only when omitted exact metadata matters. `symbol_outline` is not paginated and accepts no `offset` or `cursor`. Increase its limit or depth only when needed. `fast_context.queries` accepts at most four entries; use `detail="expanded"` when its compact shortlist is insufficient. Normal MCP responses are trimmed toward 24 KiB while preserving IDs, paths, ranges, and any trust or truncation evidence the result needs. Modern MCP clients receive the canonical structured result without a duplicate text mirror; older clients retain the compatibility mirror without charging both copies against the useful-evidence budget. `symbol_references` accepts either a copied `symbol_id` or an exact `query` scoped by `path`. For JSX/TSX components, incoming `usage` includes render-call consumers. An empty result is not proof of non-use: check its coverage and trust metadata. Relationship kinds belong to `symbol_references`, not `symbol_search`. MCP ranges use one-based lines and zero-based characters; the single `line` on a relationship observation is one-based and its `byte_offset` is zero-based. Same-line calls retain distinct offsets. `symbol_references` returns at most ten complete observations per page; follow `next_cursor` when more remain. `edit_impact` adds at most twelve convention-related indexed test paths beside structurally reached tests, and that shortlist is deliberately non-exhaustive. Resolved relationship evidence uses named tiers: `proven`, `receiver_typed`, `unique_name`, and `unique_method_name`. Treat these as evidence classes, not calibrated probabilities. `unique_method_name` can help explain a direct observation, but it is not allowed to extend a graph or trace, form a path hop, or carry multi-hop edit impact. Relationships never resolve across language families. If a paginated relationship response reports a gap, follow its gap cursor before calling a broad result complete. TypeScript, TSX, JavaScript, JSX, and Astro preserve named-import provenance, including aliases. Scout resolves local relative imports and `@/` / `~/` root-style aliases only when unambiguous; it leaves ambiguous targets unresolved rather than guessing. For Rust, qualified calls through proven `Self` owners, crate/module paths, explicit imports, aliases and re-exports, renamed workspace dependencies, and exact UFCS syntax can resolve with confidence `1.0`. Glob imports, missing dependencies, generated or macro-expanded structure, non-literal modules, unproven trait selection, and failed or ambiguous qualifiers remain unresolved. Never replace an unresolved qualifier with a text-only match on its terminal method name. For Go, calls can resolve through declared package identity, exact indexed imports, test-package boundaries, conservative build constraints, and simple statically proven receiver types. Concrete method identities include the normalized receiver type, so same-named methods on different types remain separate definitions with separate callers. Missing package, import, receiver, or variant proof must remain unresolved. Do not substitute a project-wide same-name symbol, download dependencies, or describe the result as compiler-complete type analysis. For C++, literal includes and bare, qualified, dot-member, arrow-member, and implicit-owner call observations can contribute a precision-first subset. Only exact lexical ownership, simple static receiver evidence, same-file definitions, or directly resolved include visibility should be treated as a resolved edge. Support remains partial: do not infer transitive includes, template overload selection, virtual dispatch, function-pointer targets, arbitrary receiver types, build variants, or external-library symbols. `symbol_architecture` pre-aggregates file counts, observes cancellation, and has an internal five-second work budget. A host timeout or cancellation should be respected; do not launch a second equivalent architecture query in parallel. ## 6. Offer the optional Pro trial once Free is permanent and accountless. Pro (the eight advanced tools) offers a 14-day full evaluation with no payment card. Only after Free is installed, the workspace is verified, and host setup is complete, run the network-free `atlas-scout license status`. If Pro or an evaluation is already active, do not offer the trial. If the effective edition is Free, ask once in the current setup conversation: > Atlas Scout Free is installed and ready. There is also an optional 14-day Pro trial that adds > eight advanced navigation tools. It opens a browser for email verification, requires no payment > card, starts immediately when authorized, and returns to Free automatically with no charge when > it ends. Would you like me to start the trial, or leave Atlas Scout on Free? Do not describe this as activating Atlas Scout: Free is already active and useful. Do not open the browser, create an account, or start the one-per-account trial without an explicit yes. If the user declines, continue on Free without repeating the offer. Never add a trial reminder to `AGENTS.md`, `CLAUDE.md`, or another persistent repository instruction. If the user accepts, explain that `--label` names the installation on the account's devices page, then ask for a label or propose one like the machine's hostname. `--label` is required on `trial` and `activate`: ```sh atlas-scout license trial --label "My laptop" # one-per-account evaluation atlas-scout license activate --label "My laptop" # activates a held license atlas-scout license status # network-free, redacted ``` Both open a browser confirmation at https://atlasscout.dev/activate. Do not start a trial without the user's explicit request - it is one per account and begins immediately. Trial expiry and cancellation are non-destructive: the index, settings, and all Free tools remain. `activate` applies to accounts that already hold a license; current purchase options are shown at https://atlasscout.dev/pricing and in the signed-in account dashboard. **Credential storage.** Credentials go to the platform keychain by default (Secret Service/KWallet on Linux, Keychain on macOS, Windows Credential Manager on Windows). On a headless or minimal Linux system - SSH session, container, no GNOME Keyring/KWallet - the native store is unavailable: before starting browser authorization, add `--credential-store file --credential-directory ` (use a dedicated user-only directory, e.g. `~/.config/atlas-scout/creds` with mode 0700). If activation ever reports that the response "could not be safely committed", the native store failed - re-run with the file backend and tell the user what happened. After a license change, reconnect or restart the MCP client so the new edition's tools are offered (same as after `mcp add`). ## 7. Updating Atlas Scout checks for updates only when explicitly asked. First run the native, read-only signed-channel check: ```sh atlas-scout upgrade --check --json ``` Accept only JSON schema version `1`. A nonzero exit, malformed output, unknown schema, or trust/network failure is a failed check - never report it as current and never bypass it with the bootstrap installer. The expected statuses are: - `current` - report that the installed release is current; change nothing. - `newer_local` - report that the installed release is newer than the channel; change nothing. - `available` - report the exact `current_version` and `latest_version`, then ask the user whether to install the unsigned preview. - `upgraded` - valid only after an approved installation; use `installed_path` as the stable command path. Only after the user approves an `available` update, run: ```sh atlas-scout upgrade --accept-unsigned-preview --json ``` Require schema version `1`, `status: "upgraded"`, `metadata_verified: true`, and `archive_verified: true`. The native updater verifies the signed release metadata and complete archive, smoke-tests both executables, and atomically selects the runtime pair, Claude Code plugin, documentation, and notices together. It does not modify indexes, licenses, host configuration, shell profiles, or project files. If the installed binary does not recognize the `upgrade` command, distinguish that from a native verification failure and use the section 1 bootstrap workflow once. Do not scrape release JSON or invoke the bootstrap installer as a fallback after the native verifier rejects an update. After it finishes: 1. If `daemon_was_running` is true, tell the user explicitly that the daemon retains the previous executable until restarted. Stop it and start it again so it runs the new version. 2. Start a new session in each MCP host - hosts respawn `atlas-scout mcp` from the updated binary at session start. Do not kill the `atlas-scout mcp` process serving your own current session; you would cut off your own tools mid-conversation. To tell the processes apart, check parentage: `pgrep -x atlas-scout | xargs -r ps -o pid,ppid,etime,args -p`. A process whose parent is PID 1 (or whose parent no longer exists) was orphaned by a closed session and is safe to stop with a plain `kill ` (SIGTERM, never `-9`). A process with a live parent belongs to a running host session - your own session's server has your own MCP host among its ancestors - so leave it alone; it is replaced when that session restarts. If ownership is not certain, do not kill: a stale process costs little and exits with its host. 3. Verify with `atlas-scout --version` and `atlas-scout doctor --workspace /absolute/path/to/project`. The workspace index is preserved across updates - never delete `.atlas/` as part of an update. If `doctor` reports an index compatibility issue after updating, re-run `atlas-scout index` on the workspace. An update that advances a language extractor can re-extract unchanged files once during the first reconciliation so new relationship evidence is present. That first open may take longer than a normal warm start. If rolling back to a binary that cannot open the newer disposable database schema, stop Scout, remove `.atlas/scout/`, and rebuild; source files are never part of that cache. ## 8. Sharing and troubleshooting - All local clients on a workspace share `.atlas/scout/symbols.db` automatically - one client can index, another can query. The optional `atlas-scoutd` daemon adds warmth and unsaved-buffer overlays; it is not required for sharing, and MCP discovers it automatically. If another process owns the writer lock, `index.shared_read_only` reports that reads remain available. - `atlas-scout doctor` diagnoses workspace, index storage, coverage, and host setup. - To reset an index: confirm the path with `doctor`, stop Atlas Scout processes, remove `.atlas/scout/`, and run `atlas-scout index` again. The index holds no user-authored state; never remove it mid-write. - Unsupported languages and failed files appear in `symbol_schema` health metadata rather than silently vanishing. Full documentation: https://atlasscout.dev/docs