Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

docs(runtimes): fix the discovery and coverage tables

Saurav Singhb2b84ea26c1c
diff --git a/docs/runtimes/gemini-cli.mdx b/docs/runtimes/gemini-cli.mdx
index d7f893c0..1d5f89dc 100644
--- a/docs/runtimes/gemini-cli.mdx
+++ b/docs/runtimes/gemini-cli.mdx
@@ -13,7 +13,7 @@ Before enabling Gemini CLI telemetry, make sure:
- Gemini CLI is installed and available as the `gemini` executable for the user or managed endpoint.
- `beacon endpoint install` has run so the local collector, endpoint config, and runtime log path exist.
-- Gemini is detectable through its executable or user configuration. If automatic discovery is unavailable in an unattended environment, explicitly include it with `beacon endpoint install --harness claude,codex,gemini`.
+- Gemini is detected only through the `gemini` executable on `PATH`; its user configuration alone does not make it detectable. If the executable is not on `PATH`, or automatic discovery is unavailable in an unattended environment, explicitly include it with `beacon endpoint install --harness claude,codex,gemini`.
- No project settings or `GEMINI_TELEMETRY_*` environment variables override the user-level Beacon settings you expect to use.
- Your team has reviewed content handling and destination access for prompt telemetry.
diff --git a/docs/runtimes/github-copilot-cli.mdx b/docs/runtimes/github-copilot-cli.mdx
index ab64ae8f..b5342c3d 100644
--- a/docs/runtimes/github-copilot-cli.mdx
+++ b/docs/runtimes/github-copilot-cli.mdx
@@ -38,7 +38,7 @@ Beacon reports Copilot CLI telemetry as configured only when `COPILOT_OTEL_ENABL
`beacon endpoint install` prepares the collector, endpoint config, and runtime log paths. Copilot CLI telemetry is configured outside Beacon through MDM, shell profile management, or another customer-owned launch policy.
-Do not add Copilot CLI to the `--harness` list. If `copilot`, `copilot_cli`, or `github_copilot` is passed to `beacon endpoint install --harness` or `beacon endpoint repair --harness`, Beacon reports that Copilot CLI telemetry is MDM-managed instead of writing Copilot configuration directly.
+Do not add Copilot CLI to the `--harness` list. If `copilot`, `copilot_cli`, or `github_copilot` is passed to `beacon endpoint install --harness` or `beacon endpoint repair --harness`, Beacon rejects it as an unsupported harness and writes no Copilot configuration.
Configure Copilot CLI's launch environment to export to the local OTLP HTTP receiver:
diff --git a/docs/runtimes/goose.mdx b/docs/runtimes/goose.mdx
index 5693d909..b7758e88 100644
--- a/docs/runtimes/goose.mdx
+++ b/docs/runtimes/goose.mdx
@@ -140,7 +140,7 @@ use for manual goose configuration.
### The file is not the whole answer
-Three environment conditions leave the config file saying "local" while goose exports nothing, so `beacon endpoint status` reads the environment as well as the file:
+Three environment conditions leave the config file saying "local" while goose exports nothing, so check goose's launch environment as well as the file:
| Condition | What goose does |
|-----------|-----------------|
@@ -148,7 +148,7 @@ Three environment conditions leave the config file saying "local" while goose ex
| `OTEL_SDK_DISABLED=true` | Disables every signal |
| `OTEL_EXPORTER_OTLP_PROTOCOL` set to a gRPC variant | goose **disables the signal** rather than panicking its exporter threads, with one stderr warning as the only sign |
-Reporting "enabled" from the file alone would say a runtime is covered when it is silent, so each of these is reported as misconfigured with the variable named.
+Beacon has no goose discovery or status check yet, so nothing reports these for you: check each variable yourself.
## Discovery and status
@@ -287,7 +287,7 @@ If goose hook telemetry is missing:
If goose token usage or model data is missing:
- Confirm `otel_exporter_otlp_endpoint` is in `~/.config/goose/config.yaml` and names the collector's **HTTP** port, not the gRPC one.
-- Check `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_SDK_DISABLED` and `OTEL_EXPORTER_OTLP_PROTOCOL` in goose's launch environment. Each can silently turn the export off or redirect it, and `beacon endpoint status` names whichever one is doing it.
+- Check `OTEL_EXPORTER_OTLP_ENDPOINT`, `OTEL_SDK_DISABLED` and `OTEL_EXPORTER_OTLP_PROTOCOL` in goose's launch environment. Each can silently turn the export off or redirect it, and Beacon does not check them for goose.
- Confirm the collector is running and listening on the HTTP port.
## Related
diff --git a/docs/runtimes/index.mdx b/docs/runtimes/index.mdx
index 6c88b626..d1e27153 100644
--- a/docs/runtimes/index.mdx
+++ b/docs/runtimes/index.mdx
@@ -26,7 +26,7 @@ These integrations are grouped by where the agent runs and how telemetry is coll
| [Codex CLI](/runtimes/codex-cli) | Local OTLP logs, selective usage trace, endpoint hooks, and poll of `~/.codex/sessions` through `beacon endpoint codex sync` | OTLP/hooks: session, prompt, approval, and tool-result activity plus per-user/session/model turn token usage. Poll: historical prompts, assistant messages, commands, files, tool calls, MCP-shaped activity, and token snapshots where persisted |
| [Cursor](/runtimes/cursor) | Native hooks plus optional poll of Cursor's local session stores through `beacon endpoint cursor sync` | Hooks: prompt, tool, shell command, MCP-like, approval, file edit, reasoning, and context telemetry. Poll: historical Composer and agent-session records from Cursor's global storage database and `~/.cursor/projects` |
| [DeepSeek Harness](/runtimes/deepseek-harness) | DeepSeek's own Claude Code hook bridge, mounted by a Beacon row in `$DSH_HOME/cordis.patch.yml` at a hooks file Beacon owns, plus poll of `$DSH_HOME/sessions` through `beacon endpoint dsh sync` | Hooks: session start, prompts, pre-tool and post-tool activity, commands with output and exit code, file reads and edits with diffs, MCP tool calls, subagent start and stop, and the turn-closing stop. Poll: historical prompts, assistant text/reasoning, tool calls/results, failed tools, command/file/MCP activity, and token usage where persisted. No approval decisions, because neither surface exposes them |
-| [Devin CLI](/runtimes/devin) | Native hooks | Session, prompt, pre-tool, post-tool, permission request, stop, session-end, approval, and file telemetry |
+| [Devin CLI](/runtimes/devin) | Native hooks plus optional poll of Devin CLI's `sessions.db` through `beacon endpoint devin sync` | Hooks: session, prompt, pre-tool, post-tool, permission request, stop, session-end, approval, and file telemetry. Poll: historical sessions plus assistant messages, reasoning, token usage, per-turn model, and rejected tool calls the hook payload does not carry |
| [Devin Desktop](/runtimes/devin-desktop) | Cascade/Windsurf hooks | Prompt, command, MCP tool, file read, and file write telemetry where Desktop exposes Cascade hook payloads |
| [Factory Droid](/runtimes/factory-droid) | OTLP HTTP, optional hooks, and poll of `~/.factory/sessions` through `beacon endpoint factory sync` | OTLP/hooks: session, prompt, write/edit/create tool use, stop, session-end, and available OTLP telemetry. Poll: historical session records committed by Factory |
| [fx (Vercel Labs)](/runtimes/vercel-fx) | Poll of fx's own session records under `~/.fx/sessions` through `beacon endpoint fx sync` | Session start, prompts, tool calls, commands with exit codes and output, file reads and edits with diffs, MCP tool calls, agent messages, history compaction, and token usage and cost. No approval or session-end telemetry, because fx persists neither |
diff --git a/docs/runtimes/integration-model.mdx b/docs/runtimes/integration-model.mdx
index bc266c47..aa516a11 100644
--- a/docs/runtimes/integration-model.mdx
+++ b/docs/runtimes/integration-model.mdx
@@ -15,6 +15,7 @@ Beacon supports multiple [runtime surfaces](/concepts/core-concepts#runtime-surf
|---------|--------------------------------------|
| [Claude Code](/runtimes/claude-code) | Looks for the `claude` executable and Claude settings paths |
| [Codex CLI](/runtimes/codex-cli) | Looks for the `codex` executable and `~/.codex/config.toml` |
+| [Antigravity CLI](/runtimes/antigravity-cli) | Looks for the `antigravity` or `antigravity-cli` executable, treating `~/.gemini/config` or `./.agents` as an extra signal, then checks `hooks.json` there (the project file wins when present) for Beacon's hooks |
| [Gemini CLI](/runtimes/gemini-cli) | Looks for the `gemini` executable and `~/.gemini/settings.json` |
| [GitHub Copilot CLI](/runtimes/github-copilot-cli) | Looks for the `copilot` executable or `~/.copilot/config.json`, then validates Copilot OTel environment variables |
| [DeepSeek Harness](/runtimes/deepseek-harness) | Looks for the `dsh` executable or `$DSH_HOME` (default `~/.dsh`), then checks both Beacon's owned hook file and its mount row in `cordis.patch.yml` |
@@ -24,14 +25,16 @@ Beacon supports multiple [runtime surfaces](/concepts/core-concepts#runtime-surf
| [OpenCode](/runtimes/opencode) | Looks for the `opencode` executable or `~/.config/opencode`, then checks the managed Beacon plugin |
| [Cline](/runtimes/cline) | Looks for `~/.cline`, treating a `cline` executable as an extra signal because the VS Code and JetBrains hosts ship none, then checks the managed Beacon plugin |
| [Pi](/runtimes/pi) | Looks for the `pi` executable, treating `~/.pi/agent` as an extra signal because an npm or version-manager install is often off the inherited `PATH`, then checks for Beacon's managed extension at `~/.pi/agent/extensions/beacon.ts` |
+| [Prime Agent](/runtimes/prime-agent) | Looks for the `prime-agent` executable, treating the resolved agent directory as an extra signal for the same reason as Pi, then checks for Beacon's managed extension at `~/.prime/agent/extensions/beacon.ts` |
+| [Senpi](/runtimes/senpi) | Looks for the `omo` executable, treating the resolved agent directory as an extra signal for the same reason as Pi, then checks for Beacon's managed extension at `~/.omo/agent/extensions/beacon.ts` |
| [Oh My Pi](/runtimes/oh-my-pi) | Looks for the `omp` executable, treating the resolved agent directory as an extra signal for the same reason as Pi, then checks for Beacon's managed extension at `~/.omp/agent/extensions/beacon.ts` |
| [fx (Vercel Labs)](/runtimes/vercel-fx) | Looks for the `fx` executable, treating `~/.fx` as an extra signal, then reports how much of the session store under `~/.fx/sessions` a sweep has actually collected. There is no managed file to check, so collection progress is the only honest evidence telemetry is flowing |
| [Muse Code](/runtimes/muse-code) | Checks Muse's config directory (`$XDG_CONFIG_HOME/muse`, else `~/.config/muse`) for Beacon's managed hooks file and for the `managed_hooks_path` key in Muse's own `settings.json`. Both are reported, because either one alone is a broken install that Muse says nothing about |
-| [goose](/runtimes/goose) | Looks for the `goose` executable, treating goose's own `config.yaml` as an extra signal because the desktop app installs no binary on the inherited `PATH`, then checks both the plugin directory (`$GOOSE_PATH_ROOT`, else `~/.agents/plugins/beacon-endpoint/`, and `<repo>/.agents/plugins/beacon-endpoint/`) and `config.yaml` for the OTLP endpoint. Both are reported because they are two different collection paths, and one installed without the other is half an integration |
| [Kiro](/runtimes/kiro) | Checks `<repo>/.kiro/hooks/beacon-endpoint.json` and the user-level file (`$KIRO_HOME`, else `~/.kiro`) for Beacon's hook commands. Both scopes are reported because Kiro merges hook files across scopes rather than resolving them by precedence, so both can be live at once |
| [OpenHands](/runtimes/openhands) | Checks `<repo>/.openhands/hooks.json` and the user-level file (`$OH_PERSISTENCE_DIR`, else `~/.openhands`) for Beacon's hook commands. Both scopes are reported, because OpenHands reads the first file it finds rather than merging them, so a repository file shadows the user one entirely |
| [Qwen Code](/runtimes/qwen-code) | Looks for the `qwen` executable, treating `~/.qwen` as an extra signal because an npm or version-manager install is often off the inherited `PATH`, then checks `~/.qwen/settings.json` for Beacon's `--platform qwen` hook entries |
-| [Devin CLI](/runtimes/devin) | Looks for the `devin` executable, `~/.config/devin`, or `./.devin`, then checks Beacon hook configuration |
+| [Hermes Agent](/runtimes/hermes-agent) | Looks for the `hermes` executable or the Hermes home directory (`$HERMES_HOME`, else `~/.hermes`), then checks its `config.yaml` for Beacon's shell hooks |
+| [Devin CLI](/runtimes/devin) | Looks for the `devin` executable, `~/.config/devin`, `./.devin`, or Devin CLI's `sessions.db`, then checks Beacon hook configuration and notes session history that `beacon endpoint devin sync` can read |
| [Devin Desktop](/runtimes/devin-desktop) | Checks Cascade/Windsurf hook configuration at `~/.codeium/windsurf/hooks.json` or `./.windsurf/hooks.json` |
| [Factory Droid](/runtimes/factory-droid) | Looks for the `droid` executable and validates `OTEL_TELEMETRY_ENDPOINT` in the effective launch environment |
| [Cursor](/runtimes/cursor) | Looks for the Cursor binary or `~/.cursor`, then checks Beacon hook configuration |
@@ -44,8 +47,8 @@ During install, Beacon configures the runtime surfaces it can safely manage:
| Runtime or surface | Install-time behavior |
|--------------------|-----------------------|
-| [Claude Code](/runtimes/claude-code) | Beacon points Claude Code at the local OTLP collector. Hook installation is separate through [`beacon endpoint hooks`](/cli/hooks). Historical transcripts can be backfilled with `beacon endpoint claude sync`. |
-| [Codex CLI](/runtimes/codex-cli) | Beacon points Codex CLI at the local OTLP collector, writes log and trace exporter tables to `~/.codex/config.toml`, enables prompt logging, retains one usage-bearing turn span, and installs a metadata-only SessionStart identity hook. Historical sessions can be backfilled with `beacon endpoint codex sync`. |
+| [Claude Code](/runtimes/claude-code) | Beacon points Claude Code at the local OTLP collector and installs its user-level hooks alongside, because the OTLP export carries no session lifecycle, file activity, or subagent events. Use [`beacon endpoint hooks`](/cli/hooks) for project scope or to manage the hooks on their own. Historical transcripts can be backfilled with `beacon endpoint claude sync`. |
+| [Codex CLI](/runtimes/codex-cli) | Beacon points Codex CLI at the local OTLP collector, writes log and trace exporter tables to `~/.codex/config.toml`, enables prompt logging, retains one usage-bearing turn span, and installs a SessionStart identity hook plus a Stop hook that records the turn's final reply from `last_assistant_message` as `agent.message`. Historical sessions can be backfilled with `beacon endpoint codex sync`. |
| [Gemini CLI](/runtimes/gemini-cli) | The default endpoint install detects Gemini and writes local OTLP settings to `~/.gemini/settings.json`, sets `target` to `local`, uses OTLP gRPC, enables the collector, and removes `outfile` so telemetry flows to Beacon. |
| [VS Code](/runtimes/vscode) | The default endpoint install detects VS Code, writes Copilot Chat OTel settings to VS Code user settings, points OTLP/HTTP to the local collector, and installs user-level hooks. |
| [GitHub Copilot CLI](/runtimes/github-copilot-cli) | Copilot's OTLP HTTP endpoint remains under MDM or customer-owned launch-environment policy. Beacon validates `COPILOT_OTEL_ENABLED=true` and a localhost OTLP endpoint but does not write Copilot configuration. Committed sessions can be backfilled with `beacon endpoint copilot sync`. |
@@ -75,11 +78,11 @@ During install, Beacon configures the runtime surfaces it can safely manage:
| [Prime Agent](/runtimes/prime-agent) | Managed local extension through `beacon-hooks`, plus poll of Prime Agent's local session store | The other pi-mono fork, sharing Pi's event payload shapes and so Pi's mapper, but never Pi's identity: separate harness name, separate extension marker, separate install directory. Its persistent Python kernel cells are recorded as commands, and `beacon endpoint prime sync` backfills committed sessions and subagent artifacts as poll events. |
| [fx (Vercel Labs)](/runtimes/vercel-fx) | Poll of fx's own session store | fx exposes no third-party observation surface: its lifecycle hooks are compiled into the binary, it has no OpenTelemetry export, and its plugin story is MCP. Beacon reads the append-only session records under `~/.fx/sessions` and marks every event `harness.collection_method=poll`, so a consumer knows nothing on this path could have been intercepted. |
| [Muse Code](/runtimes/muse-code) | Native hook payloads through `beacon-hooks` | Beacon writes a managed hooks file it owns outright and points Muse's own `settings.json` at it with the `managed_hooks_path` key, then maps session, prompt, tool, command, file, approval, subagent, and compaction events into endpoint events. Muse ships an OTLP export that cannot be pointed at a local collector, so hooks are the only collection path. |
-| [goose](/runtimes/goose) | Native hook payloads through `beacon-hooks`, plus goose's own OTLP export | Beacon installs a plugin of its own into the `.agents/plugins` directory goose discovers, leaving every other plugin untouched, then maps session, prompt, tool, command, file and MCP events into endpoint events. goose populates no tool output on a hook, so the second path is not optional in practice: pointing goose's OpenTelemetry export at the local collector is what carries token usage, model, provider and reasoning. goose classifies a blocking hook's stdout, so Beacon answers `PreToolUse` and `Stop` with an explicit allow rather than the usual no-op object. |
+| [goose](/runtimes/goose) | Native hook payloads through `beacon-hooks`, plus goose's own OTLP export | Adapter only: Beacon has no goose installer or discovery. A plugin and its `hooks/hooks.json` written by hand into the `.agents/plugins` directory goose discovers invoke `beacon-hooks --platform goose`, and Beacon maps session, prompt, tool, command, file and MCP events into endpoint events. goose populates no tool output on a hook, so the second path is not optional in practice: pointing goose's OpenTelemetry export at the local collector is what carries token usage, model, provider and reasoning. goose classifies a blocking hook's stdout, so Beacon answers `PreToolUse` and `Stop` with an explicit allow rather than the usual no-op object. |
| [Kiro](/runtimes/kiro) | Native hook payloads through `beacon-hooks` | Beacon writes one hook file of its own into the `.kiro/hooks/` directory Kiro scans, leaving every other file in it untouched, then maps session, prompt, tool, command, file, MCP and agent-response events into endpoint events. Kiro's hook contract is exit codes rather than response objects, so Beacon writes nothing to stdout: on the two events Kiro reads it for, stdout is added to the model's context. |
| [OpenHands](/runtimes/openhands) | Native hook payloads through `beacon-hooks` | Beacon merges its six commands into the `.openhands/hooks.json` the runtime already reads, preserving hooks you wrote, then maps session, prompt, tool, command, file, and MCP events into endpoint events. File edits carry an exact diff, because OpenHands reports the file's content before and after rather than the edit instruction. |
| [Qwen Code](/runtimes/qwen-code) | Native hook payloads through `beacon-hooks` | Beacon merges a managed hook block into Qwen's own `settings.json` and maps session, prompt, tool, command, file, failed-tool, approval, and subagent events into endpoint events. Qwen Code is a Gemini CLI fork without Gemini's OTLP export, so hooks are the only collection path. |
-| [Devin CLI](/runtimes/devin) | Native hook payloads through `beacon-hooks` | Hooks emit session, prompt, pre-tool, post-tool, permission request, stop, session-end, approval, and file telemetry where Devin CLI exposes payloads. |
+| [Devin CLI](/runtimes/devin) | Native hook payloads through `beacon-hooks`, plus poll of Devin CLI's `sessions.db` | Hooks emit session, prompt, pre-tool, post-tool, permission request, stop, session-end, approval, and file telemetry where Devin CLI exposes payloads. `beacon endpoint devin sync` backfills committed sessions as poll events and adds what the hook payload does not carry: assistant text, reasoning, token usage, the per-turn model, and rejected tool calls. |
| [Devin Desktop](/runtimes/devin-desktop) | Cascade/Windsurf hook payloads through `beacon-hooks` | Hooks emit prompt, command, MCP tool, file read, and file write telemetry where Devin Desktop exposes Cascade/Windsurf payloads. |
| [Factory Droid](/runtimes/factory-droid) | OTLP HTTP launch environment, optional hooks, and poll of `~/.factory/sessions` | Beacon validates Factory OTLP state but does not mutate shell profiles for Droid. `beacon endpoint factory sync` backfills committed sessions as poll events. |
| [Cursor](/runtimes/cursor) | Native hook payloads through `beacon-hooks`, plus poll of Cursor's local session stores | Hooks emit session, prompt, tool, command, MCP-like, approval, reasoning, context, and file edit telemetry where Cursor exposes payloads. `beacon endpoint cursor sync` backfills committed Composer and agent-session records as poll events. |
@@ -112,7 +115,7 @@ that is better represented as runtime events than generic OTLP spans.
| [Pi](/runtimes/pi) | Session lifecycle, prompt submission, tool invocation and results, command execution including operator `!` commands, file reads, creates, and edits with the unified patch, agent reasoning from assistant thinking parts, and token usage and cost. Approval decisions are not exposed by Pi's extension API and are not synthesized. |
| [Oh My Pi](/runtimes/oh-my-pi) | Everything Pi reports, plus real operator approval decisions carrying the command or file being decided on, the session's approval mode, and the tool call id. Commands include operator `!` shell and `$` Python prefixes. MCP tool activity carries the server and tool Oh My Pi reports on the call's result, including calls made through its `xd://` tool devices. File paths are recorded as the absolute files Oh My Pi resolved them to. |
| [Muse Code](/runtimes/muse-code) | Session start, prompt submission, pre-tool and post-tool activity, permission requests, subagent start and stop, context compaction, stop events, command execution, and file activity. Hook timeouts are second values. User scope only: Muse's project `.muse/hooks.json` is ignored by the shipping build. |
-| [goose](/runtimes/goose) | Session start and end, prompt submission, pre-tool and post-tool activity, post-tool failures, stop events, command lines, and file activity with diffs. Hook timeouts are second values. The two scopes replace each other rather than merging: goose deduplicates plugins by name with project scope first, so one install is one registration. |
+| [goose](/runtimes/goose) | Session start and end, prompt submission, pre-tool and post-tool activity, post-tool failures, stop events, command lines, and file activity with diffs. Hook timeouts are second values. The two scopes replace each other rather than merging: goose deduplicates plugins by name with project scope first, so a hand-written plugin of the same name registers once. |
| [Kiro](/runtimes/kiro) | Session start, prompt submission, pre-tool and post-tool activity, stop events with the agent's final response, command execution with output, and file activity. Hook timeouts are second values, and `0` means no timeout rather than the default. One install covers the Kiro IDE and the Kiro CLI, because they are one harness reading one hooks directory; both scopes are live at once, because Kiro merges them. |
| [OpenHands](/runtimes/openhands) | Session start and end, prompt submission, pre-tool and post-tool activity, stop events, command execution with exit code and output, and file activity with exact before/after diffs. Hook timeouts are second values. Both scopes work, but project scope is the one every host reads: OpenHands takes the first hooks file it finds, and its agent server never consults the user-level one. |
| [Qwen Code](/runtimes/qwen-code) | Session lifecycle, prompt submission, pre-tool and post-tool activity, post-tool failures, permission requests, subagent start and stop, stop events, session-end events, command execution, and file activity where payloads are available. Hook timeouts are millisecond values, and project-level hooks require a trusted folder in Qwen. |