The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
docs: cover fx and Prime Agent, and close the runtime-table gaps
Claude0dccfac8652d
diff --git a/README.md b/README.mdindex d870c4b5..ee7c29a1 100644--- a/README.md+++ b/README.md@@ -77,7 +77,7 @@ event model extends to CI and cloud-agent paths under customer control.| [Devin CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-devin) | Native hooks | Session, prompt, pre-tool, post-tool, permission request, stop, session end, approval, and file || [Devin Desktop](https://docs.asymptotelabs.ai/cli/supported-runtimes-devin-desktop) | Cascade/Windsurf hooks | Prompt, command, MCP tool, file read, and file write || [Factory Droid](https://docs.asymptotelabs.ai/cli/supported-runtimes-factory-droid) | OTLP HTTP plus optional hooks | Session, prompt, write/edit/create tool use, stop, and session end |-| [fx (Vercel Labs)](https://github.com/vercel-labs/fx) | Poll of fx's own session records under `~/.fx/sessions/` through `beacon endpoint fx sync`; events land a turn late and cannot gate a tool call | Session start, prompts, tool calls, commands with exit codes and output, file reads/creates/edits with diffs, MCP tool calls, agent messages, compaction, and token usage/cost. No approval or session-end record, because fx persists neither |+| [fx (Vercel Labs)](https://docs.asymptotelabs.ai/runtimes/vercel-fx) | Poll of fx's own session records under `~/.fx/sessions/` through `beacon endpoint fx sync`; events land a turn late and cannot gate a tool call | Session start, prompts, tool calls, commands with exit codes and output, file reads/creates/edits with diffs, MCP tool calls, agent messages, compaction, and token usage/cost. No approval or session-end record, because fx persists neither || [Gemini CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-gemini-cli) | Opt-in local OTLP | Prompts, tool calls, MCP activity, file operations, and approval-related events || [GitHub Copilot CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-github-copilot-cli) | MDM-managed OTLP HTTP | Prompt, session, tool, and approval-like activity || [Grok Build](https://docs.asymptotelabs.ai/cli/supported-runtimes-grok-build) | Native hooks | Session, prompt, pre-tool, post-tool, failed tool, stop, session end, command, and file |diff --git a/docs/cli/endpoint-discover.mdx b/docs/cli/endpoint-discover.mdxindex 7f8ee5a9..aa83f438 100644--- a/docs/cli/endpoint-discover.mdx+++ b/docs/cli/endpoint-discover.mdx@@ -13,7 +13,7 @@ beacon endpoint discoverBeacon discovers local runtime surfaces and reports their telemetry configuration state, including whether supported configuration appears Beacon-managed or customer-managed. By default, discover prints detected targets. Add `--all` to include every supported runtime target, including runtimes that are not detected on the host. OpenClaw Gateway is validated through the `beacon endpoint integrations openclaw` commands after Gateway diagnostics export is configured.-Gemini CLI discovery looks for the `gemini` executable and `~/.gemini/settings.json`, then checks whether local OTLP telemetry is enabled for Beacon. VS Code discovery checks Copilot Chat OpenTelemetry configuration and reports Beacon-managed state when the OTLP endpoint points at Beacon's local receiver. GitHub Copilot CLI discovery looks for the `copilot` executable or `~/.copilot/config.json`, then validates that `COPILOT_OTEL_ENABLED=true` and the effective OTLP endpoint points at Beacon's local HTTP receiver, usually `http://127.0.0.1:4318`. Claude Code discovery looks for the `claude` executable and Claude settings paths; optional Claude hook status is available through `beacon endpoint hooks status --harness claude`. Antigravity CLI discovery looks for the `antigravity` or `antigravity-cli` executable, `~/.gemini/config`, or `./.agents`, then checks whether Beacon endpoint hooks are installed in `~/.gemini/config/hooks.json` or `./.agents/hooks.json`. Grok Build discovery checks whether Beacon's managed hook file is installed at `~/.grok/hooks/beacon-endpoint.json` or `./.grok/hooks/beacon-endpoint.json`. Hermes Agent discovery looks for the `hermes` executable or `~/.hermes`, then checks `~/.hermes/config.yaml` for Beacon-managed hooks, identified by the endpoint settings flags (`--log`, `--config`, `--cli`) or a legacy `BEACON_ENDPOINT_MODE=1` prefix, together with `--platform hermes`. OpenCode discovery looks for the `opencode` executable or `~/.config/opencode`, then checks whether Beacon's managed plugin is installed at `~/.config/opencode/plugins/beacon.ts`. Cline discovery looks for `~/.cline` and treats a `cline` executable as an additional signal rather than the deciding one, because Cline's VS Code and JetBrains hosts ship no executable; it then checks whether Beacon's managed plugin is installed at `~/.cline/plugins/beacon.ts`. Pi discovery looks for the `pi` executable and treats `~/.pi/agent` as an additional signal, because an npm, pnpm, or bun install is often absent from the inherited `PATH` while its state directory is not; it then reports whether Beacon's managed extension is installed at `~/.pi/agent/extensions/beacon.ts`, and reports a `beacon.ts` without Beacon's marker as disabled rather than enabled. Qwen Code discovery looks for the `qwen` executable and treats `~/.qwen` as an additional signal, because an npm or version-manager install is often absent from the inherited `PATH` while its config directory is not; it then checks `~/.qwen/settings.json` for Beacon hook commands carrying `--platform qwen`, reporting hooks turned off by `disableAllHooks` as disabled and invalid settings JSON as misconfigured rather than missing. Devin CLI discovery looks for the `devin` executable, `~/.config/devin`, or `./.devin`, then checks whether Beacon endpoint hooks are installed in `~/.config/devin/config.json` or `./.devin/hooks.v1.json`; `devin` remains a legacy alias for `devin-cli`. Devin Desktop discovery checks Cascade/Windsurf hook files at `~/.codeium/windsurf/hooks.json` or `./.windsurf/hooks.json`. Factory Droid discovery looks for the `droid` executable and validates the effective `OTEL_TELEMETRY_ENDPOINT` launch environment without treating customer-managed shell export values as Beacon-owned configuration. Set MDM-managed launch environments to Beacon's local OTLP HTTP receiver through MDM or another customer-owned launch policy.+Gemini CLI discovery looks for the `gemini` executable and `~/.gemini/settings.json`, then checks whether local OTLP telemetry is enabled for Beacon. VS Code discovery checks Copilot Chat OpenTelemetry configuration and reports Beacon-managed state when the OTLP endpoint points at Beacon's local receiver. GitHub Copilot CLI discovery looks for the `copilot` executable or `~/.copilot/config.json`, then validates that `COPILOT_OTEL_ENABLED=true` and the effective OTLP endpoint points at Beacon's local HTTP receiver, usually `http://127.0.0.1:4318`. Claude Code discovery looks for the `claude` executable and Claude settings paths; optional Claude hook status is available through `beacon endpoint hooks status --harness claude`. Antigravity CLI discovery looks for the `antigravity` or `antigravity-cli` executable, `~/.gemini/config`, or `./.agents`, then checks whether Beacon endpoint hooks are installed in `~/.gemini/config/hooks.json` or `./.agents/hooks.json`. Grok Build discovery checks whether Beacon's managed hook file is installed at `~/.grok/hooks/beacon-endpoint.json` or `./.grok/hooks/beacon-endpoint.json`. Hermes Agent discovery looks for the `hermes` executable or `~/.hermes`, then checks `~/.hermes/config.yaml` for Beacon-managed hooks, identified by the endpoint settings flags (`--log`, `--config`, `--cli`) or a legacy `BEACON_ENDPOINT_MODE=1` prefix, together with `--platform hermes`. OpenCode discovery looks for the `opencode` executable or `~/.config/opencode`, then checks whether Beacon's managed plugin is installed at `~/.config/opencode/plugins/beacon.ts`. Cline discovery looks for `~/.cline` and treats a `cline` executable as an additional signal rather than the deciding one, because Cline's VS Code and JetBrains hosts ship no executable; it then checks whether Beacon's managed plugin is installed at `~/.cline/plugins/beacon.ts`. Pi discovery looks for the `pi` executable and treats `~/.pi/agent` as an additional signal, because an npm, pnpm, or bun install is often absent from the inherited `PATH` while its state directory is not; it then reports whether Beacon's managed extension is installed at `~/.pi/agent/extensions/beacon.ts`, and reports a `beacon.ts` without Beacon's marker as disabled rather than enabled. Oh My Pi discovery looks for the `omp` executable and treats the resolved agent directory as an additional signal for the same reason as Pi; it then reports whether Beacon's managed extension is installed at `~/.omp/agent/extensions/beacon.ts`, and honors `PI_CODING_AGENT_DIR` and `PI_CONFIG_DIR` when resolving that path. fx discovery looks for the `fx` executable and treats `~/.fx` as an additional signal; because fx has no file Beacon writes into, its telemetry status reports how much of the session store under `~/.fx/sessions` has actually been collected rather than whether a marker is present, distinguishing "no sessions yet" from "sessions present and none collected" from "collected and current". Qwen Code discovery looks for the `qwen` executable and treats `~/.qwen` as an additional signal, because an npm or version-manager install is often absent from the inherited `PATH` while its config directory is not; it then checks `~/.qwen/settings.json` for Beacon hook commands carrying `--platform qwen`, reporting hooks turned off by `disableAllHooks` as disabled and invalid settings JSON as misconfigured rather than missing. Devin CLI discovery looks for the `devin` executable, `~/.config/devin`, or `./.devin`, then checks whether Beacon endpoint hooks are installed in `~/.config/devin/config.json` or `./.devin/hooks.v1.json`; `devin` remains a legacy alias for `devin-cli`. Devin Desktop discovery checks Cascade/Windsurf hook files at `~/.codeium/windsurf/hooks.json` or `./.windsurf/hooks.json`. Factory Droid discovery looks for the `droid` executable and validates the effective `OTEL_TELEMETRY_ENDPOINT` launch environment without treating customer-managed shell export values as Beacon-owned configuration. Set MDM-managed launch environments to Beacon's local OTLP HTTP receiver through MDM or another customer-owned launch policy.## Flagsdiff --git a/docs/cli/endpoint-fx.mdx b/docs/cli/endpoint-fx.mdxnew file mode 100644index 00000000..8355b7b6--- /dev/null+++ b/docs/cli/endpoint-fx.mdx@@ -0,0 +1,110 @@+---+title: "beacon endpoint fx"+description: "Collect endpoint telemetry from fx (vercel-labs/fx) session records"+---++## Command overview++`beacon endpoint fx` collects telemetry from [fx](/runtimes/vercel-fx), Vercel Labs' native coding agent, by reading the session records fx commits under `~/.fx/sessions` and converting them into Beacon [endpoint events](/concepts/core-concepts#endpoint-event).++```bash title="Command syntax"+beacon endpoint fx [command]+```++It is a command rather than an install step because fx has nothing to install into. Every other supported runtime exposes a hook config, a plugin directory, or an OTLP endpoint, so Beacon writes something once and the runtime calls it. fx has none of those: what it has is a durable session log, so collecting from it is an action rather than a configuration.++Every event is marked `harness.collection_method=poll`. Beacon sees what a turn did once fx committed it, rather than observing the agent as it works, so nothing here can hold or deny a tool call.++Reading is local and offline. Nothing this command does reaches the network.++## Commands++| Command | Description |+|---------|-------------|+| `beacon endpoint fx sync` | Read new fx session records into the runtime log |+| `beacon endpoint fx status` | Show fx sessions on this machine and how much of each has been collected |++## Flags++Both subcommands accept:++| Flag | Description |+|------|-------------|+| `--sessions-dir <path>` | fx session directory. Defaults to `~/.fx/sessions` |+| `--state <path>` | Collector cursor file. Defaults to `~/.beacon/endpoint/state/fx.json` |+| `--json` | Print the result as JSON |+| `--user` | Use per-user endpoint paths. Enabled by default |+| `--system` | Use system endpoint paths. The cursor moves beside the system runtime log |++`sync` also accepts:++| Flag | Description |+|------|-------------|+| `--log-path <path>` | Runtime JSONL log path. Defaults to the resolved endpoint log |+| `--print` | Print mapped events as JSON without writing them or advancing the cursor |+| `--watch` | Sweep continuously on `--interval` instead of sweeping once and exiting |+| `--interval <duration>` | Sweep interval for `--watch`. Defaults to `1m`, with a 5-second floor |++## Sweeping++```bash title="Sweep once"+beacon endpoint fx sync+```++```bash title="Preview without writing anything"+beacon endpoint fx sync --print+```++`--print` is a dry run in both directions: it neither writes the runtime log nor advances the cursor, so running it twice shows the same events and running it does not quietly consume the work a later real sweep would do.++```bash title="Sweep continuously"+beacon endpoint fx sync --watch --interval 5m+```++Nothing sweeps on its own. Run `sync` under whatever scheduler the platform already uses, or leave `--watch` running.++A sweep prints what it did, and says out loud the two conditions a counter would hide:++```text+fx sync: 4 sessions, 2 changed, 37 events, 0 errors+ 1 unreadable line(s) in fx session logs+ 1 session(s) had a partly written record; it will be read on the next sweep+```++A damaged session log and an empty one produce the same event count, and only one of them is a reason to look at the machine. The summary is reported even when the sweep hit an error, because a sweep that collected nine sessions and failed on the tenth did nine sessions' worth of work.++## Status++```bash title="Show fx sessions and collection progress"+beacon endpoint fx status+```++```text+fx sessions: 2 in /Users/you/.fx/sessions+ 1788051418424-... collected seq 41/41 /Users/you/src/app+ 1788139022101-... pending seq 0/12 /Users/you/src/api+```++`collected` means the cursor is level with what fx's own manifest says it has committed, in the same log generation. A session whose manifest cannot be read is reported as pending rather than assumed collected, because it cannot say how far fx has committed.++## Cursor behavior++The cursor is what keeps a scheduled sweep from re-appending every session's whole history. It stores both the sequence number and fx's log generation, because fx restarts sequence numbers when it compacts a session log; without the generation a compaction would look like a rewind.++| Mode | Default cursor path |+|------|--------------------|+| User | `~/.beacon/endpoint/state/fx.json` |+| System | `fx-state.json` beside the system runtime log |++A sweep reads each session's log only as far as the manifest's committed watermark, so a frame fx is still writing is left for the next sweep rather than counted as corruption. Re-reading is safe: each event's dedup id comes from the record's own coordinates rather than its content, so the same fx record maps to the same event every time.++## Related++<Columns cols={2}>+ <Card title="fx (Vercel Labs)" icon="code" href="/runtimes/vercel-fx">+ Telemetry coverage, discovery, and known gaps for the runtime.+ </Card>+ <Card title="beacon endpoint discover" icon="magnifying-glass" href="/cli/endpoint-discover">+ Check whether fx is detected and how much has been collected.+ </Card>+</Columns>diff --git a/docs/cli/endpoint-inventory.mdx b/docs/cli/endpoint-inventory.mdxindex 72eb2891..890c0379 100644--- a/docs/cli/endpoint-inventory.mdx+++ b/docs/cli/endpoint-inventory.mdx@@ -21,8 +21,8 @@ Inventory can include:- Endpoint config path, runtime log path, and configured OTLP harnesses- Detected supported runtimes and telemetry status, including MDM-managed launch-environment state for GitHub Copilot CLI and Factory Droid-- Hook integration status for Antigravity CLI, Claude Code, Cline, Cursor, Devin CLI, Devin Desktop, Factory Droid, Grok Build, Hermes Agent, OpenCode, and Qwen Code-- Supported agent configuration files and MCP server configuration context where Beacon can inspect them locally, including Claude Code `~/.claude.json` and Cursor `mcp.json`+- Hook and managed-plugin integration status for Antigravity CLI, Claude Code, Cline, Cursor, Devin CLI, Devin Desktop, Factory Droid, Grok Build, Hermes Agent, Oh My Pi, OpenCode, Pi, and Qwen Code+- Supported agent configuration files and MCP server configuration context where Beacon can inspect them locally, including Claude Code `~/.claude.json`, Cursor `mcp.json`, and fx `~/.fx/settings.json`, `~/.fx/mcp.json`, and a workspace `.mcp.json`- Local agent skill manifests discovered under supported skill roots, including symlinked Claude Code skill directories, reported as metadata and hashes by default (add `--contents` for redacted full bodies)- Recently observed Beacon runtime events when the runtime log exists- Admin-configured integration observations such as Claude Cowork and OpenClaw Gateway eventsdiff --git a/docs/cli/endpoint.mdx b/docs/cli/endpoint.mdxindex 0a2aab8e..6bf1dca1 100644--- a/docs/cli/endpoint.mdx+++ b/docs/cli/endpoint.mdx@@ -24,6 +24,7 @@ beacon endpoint [command]<span id="beacon-endpoint-uninstall" /><span id="beacon-endpoint-config" /><span id="beacon-endpoint-onboarding" />+<span id="beacon-endpoint-fx" /><Columns cols={2}><Card title="beacon endpoint install" icon="download" href="/cli/endpoint-install">@@ -47,6 +48,9 @@ beacon endpoint [command]<Card title="beacon endpoint onboarding" icon="envelope" href="/cli/endpoint-onboarding">Show, reset, or resend the one-time onboarding record.</Card>+ <Card title="beacon endpoint fx" icon="rotate" href="/cli/endpoint-fx">+ Collect telemetry from fx session records on this machine.+ </Card><Card title="beacon scan" icon="magnifying-glass" href="/cli/scan">Run threat-detection rules over local endpoint telemetry.</Card>diff --git a/docs/cli/hooks.mdx b/docs/cli/hooks.mdxindex 3e8c57c6..37af5558 100644--- a/docs/cli/hooks.mdx+++ b/docs/cli/hooks.mdx@@ -40,6 +40,8 @@ beacon endpoint hooks [command]| Hermes Agent | `~/.hermes/config.yaml` | Not supported | `~/.beacon/endpoint/hooks/beacon-hooks` | `~/.beacon/endpoint/logs/runtime.jsonl` || OpenCode | `~/.config/opencode/plugins/beacon.ts` | `./.opencode/plugins/beacon.ts` | `~/.beacon/endpoint/hooks/beacon-hooks` | `~/.beacon/endpoint/logs/runtime.jsonl` || Cline | `~/.cline/plugins/beacon.ts` | `./.cline/plugins/beacon.ts` | `~/.beacon/endpoint/hooks/beacon-hooks` | `~/.beacon/endpoint/logs/runtime.jsonl` |+| Pi | `~/.pi/agent/extensions/beacon.ts` | `./.pi/extensions/beacon.ts` | `~/.beacon/endpoint/hooks/beacon-hooks` | `~/.beacon/endpoint/logs/runtime.jsonl` |+| Oh My Pi | `~/.omp/agent/extensions/beacon.ts` | `./.omp/extensions/beacon.ts` | `~/.beacon/endpoint/hooks/beacon-hooks` | `~/.beacon/endpoint/logs/runtime.jsonl` || Qwen Code | `~/.qwen/settings.json` | `./.qwen/settings.json` | `~/.beacon/endpoint/hooks/beacon-hooks` | `~/.beacon/endpoint/logs/runtime.jsonl` |In system mode, the hook binary is written under `/Library/Application Support/Beacon/Endpoint/hooks/` and the default runtime log is `/var/log/beacon-agent/runtime.jsonl`.@@ -48,7 +50,7 @@ In system mode, the hook binary is written under `/Library/Application Support/B| Flag | Description ||------|-------------|-| `--harness <list>` | Comma-separated hook harnesses, such as `antigravity`, `claude`, `cline`, `codex`, `cursor`, `devin-cli`, `devin-desktop`, `factory`, `grok`, `hermes`, `opencode`, `qwen`, or `antigravity,claude,cline,codex,cursor,devin-cli,devin-desktop,factory,grok,hermes,opencode,qwen`. `devin` remains a legacy alias for `devin-cli`; `hermes-agent` maps to `hermes`; `qwen-code` maps to `qwen`. Defaults to `cursor` |+| `--harness <list>` | Comma-separated hook harnesses, such as `antigravity`, `claude`, `cline`, `codex`, `cursor`, `devin-cli`, `devin-desktop`, `factory`, `grok`, `hermes`, `omp`, `opencode`, `pi`, `qwen`, or `antigravity,claude,cline,codex,cursor,devin-cli,devin-desktop,factory,grok,hermes,omp,opencode,pi,qwen`. `devin` remains a legacy alias for `devin-cli`; `hermes-agent` maps to `hermes`; `qwen-code` maps to `qwen`; `pi-cli` and `pi_cli` map to `pi`; `oh-my-pi` and `ohmypi` map to `omp`. Defaults to `cursor` || `--level <level>` | Hook install level: `user` or `project` || `--user` | Use per-user endpoint paths. Enabled by default || `--system` | Use system endpoint paths and launch daemon |diff --git a/docs/docs.json b/docs/docs.jsonindex b922dffb..3839f9e3 100644--- a/docs/docs.json+++ b/docs/docs.json@@ -144,12 +144,14 @@"runtimes/devin","runtimes/devin-desktop","runtimes/factory-droid",+ "runtimes/vercel-fx","runtimes/gemini-cli","runtimes/github-copilot-cli","runtimes/grok-build","runtimes/oh-my-pi","runtimes/opencode","runtimes/pi",+ "runtimes/prime-agent","runtimes/qwen-code","runtimes/vscode"]@@ -366,6 +368,7 @@"cli/endpoint-uninstall","cli/endpoint-config","cli/endpoint-onboarding",+ "cli/endpoint-fx","cli/dashboard","cli/wazuh","cli/elastic",diff --git a/docs/runtimes/index.mdx b/docs/runtimes/index.mdxindex 1facea33..a5c9cfdd 100644--- a/docs/runtimes/index.mdx+++ b/docs/runtimes/index.mdx@@ -27,15 +27,19 @@ These integrations are grouped by where the agent runs and how telemetry is coll| [Devin CLI](/runtimes/devin) | Native hooks | Session, prompt, pre-tool, post-tool, permission request, stop, session-end, approval, and file telemetry || [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 plus optional hooks | Session, prompt, write/edit/create tool use, stop, session-end, and available OTLP telemetry |+| [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 || [Gemini CLI](/runtimes/gemini-cli) | Opt-in local OTLP | Prompts, tool calls, MCP activity, file operations, and approval-related events emitted through OTLP || [GitHub Copilot CLI](/runtimes/github-copilot-cli) | MDM-managed OTLP HTTP | Prompt, session, tool, and approval-like activity emitted through Copilot CLI spans || [Grok Build](/runtimes/grok-build) | Native hooks | Session, prompt, pre-tool, post-tool, failed tool, stop, session-end, command, and file telemetry || [Oh My Pi](/runtimes/oh-my-pi) | Managed extension hooks | Session lifecycle, prompts, tool lifecycle, operator approval decisions, commands including operator `!` and `$` commands, file reads and edits with the unified patch, MCP tool activity, agent reasoning, and token usage || [OpenCode](/runtimes/opencode) | Managed plugin hooks | Chat messages, session events, command execution, permission activity, diffs, and errors || [Pi](/runtimes/pi) | Managed extension hooks | Session lifecycle, prompts, tool lifecycle, commands including operator `!` commands, file reads and edits with the unified patch, agent reasoning, and token usage |+| [Prime Agent](/runtimes/prime-agent) | Not yet collected | Harness identity only. Prime Agent is recognized as its own runtime and its collection method is defined, but no managed extension ships yet, so no events are collected || [Qwen Code](/runtimes/qwen-code) | Native hooks | Session, prompt, pre-tool, post-tool, failed tool, permission request, subagent, stop, session-end, command, and file telemetry || [VS Code](/runtimes/vscode) | Copilot Chat OTel plus optional preview hooks | Copilot session, prompt, model, and tool activity through OTel; optional hooks for extra lifecycle and cross-agent detail |+Two rows in that table are not hook or OTLP integrations. [fx](/runtimes/vercel-fx) exposes no hook, plugin, or OpenTelemetry surface at all, so Asymptote reads the session records fx commits to disk; every fx event is marked `harness.collection_method=poll`, meaning it was read after the turn was committed rather than observed as the agent worked, and nothing on that path can hold or deny a tool call. [Prime Agent](/runtimes/prime-agent) is listed because Asymptote already recognizes it as its own harness, but no managed extension ships yet, so it collects nothing today.+### Local knowledge worker agent harnesses| Agent harness | Collection path | Telemetry coverage |@@ -102,11 +106,12 @@ MDM assets, meaning Jamf Pro Extension Attributes, Fleet osquery queries, and Ri| Runtime | Enterprise configuration ||---------|--------------------------|| Gemini CLI | Opt in by adding `gemini` to the endpoint harness list, for example `claude,codex,gemini`. Asymptote can then manage `~/.gemini/settings.json` for local OTLP collection. |+| fx (Vercel Labs) | Nothing to configure in fx. Schedule [`beacon endpoint fx sync`](/cli/endpoint-fx) in the logged-in user's context, or leave `--watch` running, so committed sessions keep reaching the runtime log. Nothing sweeps on its own. || GitHub Copilot CLI | Configure launch environment through MDM or customer policy: `COPILOT_OTEL_ENABLED=true` and `OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4318`. Asymptote validates the endpoint but does not edit shell profiles or launch environments. || Factory Droid | Configure launch environment with `OTEL_TELEMETRY_ENDPOINT=http://127.0.0.1:4318`. Asymptote discovers the runtime and validates the endpoint but does not edit shell profiles or launch environments. || OpenClaw Gateway | Configure OTLP in OpenClaw. Use [`beacon endpoint integrations openclaw`](/cli/openclaw) to print local Gateway settings and validate events. |-Install hooks separately in the logged-in user's context when you need richer hook telemetry or inventory heartbeat triggers. This applies to Antigravity CLI, Claude Code, Cline, Codex CLI inventory hooks, Cursor, Devin CLI, Devin Desktop, Factory Droid, Grok Build, Hermes Agent, OpenCode, Pi, Qwen Code, and the optional VS Code hooks.+Install hooks separately in the logged-in user's context when you need richer hook telemetry or inventory heartbeat triggers. This applies to Antigravity CLI, Claude Code, Cline, Codex CLI inventory hooks, Cursor, Devin CLI, Devin Desktop, Factory Droid, Grok Build, Hermes Agent, Oh My Pi, OpenCode, Pi, Qwen Code, and the optional VS Code hooks. fx is the exception with no hooks to install: schedule [`beacon endpoint fx sync`](/cli/endpoint-fx) instead.If a system collector is running while the CLI is reading the default per-user log, `beacon endpoint status` and the local dashboard surface a runtime-log source warning so you can tell where OTLP events are being written.diff --git a/docs/runtimes/integration-model.mdx b/docs/runtimes/integration-model.mdxindex 99964ead..e236096a 100644--- a/docs/runtimes/integration-model.mdx+++ b/docs/runtimes/integration-model.mdx@@ -22,6 +22,8 @@ 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` |+| [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 || [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 || [Devin Desktop](/runtimes/devin-desktop) | Checks Cascade/Windsurf hook configuration at `~/.codeium/windsurf/hooks.json` or `./.windsurf/hooks.json` |@@ -43,7 +45,8 @@ During install, Beacon configures the runtime surfaces it can safely manage:| [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. || [Factory Droid](/runtimes/factory-droid) | Droid's OTLP endpoint remains under its launch environment, commonly managed through MDM or another customer-owned policy. || [OpenClaw Gateway](/runtimes/openclaw-gateway) | Configure OpenClaw with the `diagnostics-otel` plugin. Beacon prints local OTLP/HTTP setup guidance and validates observed events. |-| Hook-based runtimes | [Antigravity CLI](/runtimes/antigravity-cli), [Claude Code](/runtimes/claude-code), [Cline](/runtimes/cline), [Cursor](/runtimes/cursor), [Devin CLI](/runtimes/devin), [Devin Desktop](/runtimes/devin-desktop), [Factory](/runtimes/factory-droid), [Grok Build](/runtimes/grok-build), [Hermes Agent](/runtimes/hermes-agent), [OpenCode](/runtimes/opencode), and [Qwen Code](/runtimes/qwen-code) hooks are installed separately with [`beacon endpoint hooks`](/cli/hooks), because hooks are per-user or per-project runtime configuration rather than base collector service configuration. |+| [fx (Vercel Labs)](/runtimes/vercel-fx) | Nothing is installed or configured. fx has no hook file, plugin directory, or OTLP endpoint, so collection is an action: run or schedule [`beacon endpoint fx sync`](/cli/endpoint-fx). |+| Hook-based runtimes | [Antigravity CLI](/runtimes/antigravity-cli), [Claude Code](/runtimes/claude-code), [Cline](/runtimes/cline), [Cursor](/runtimes/cursor), [Devin CLI](/runtimes/devin), [Devin Desktop](/runtimes/devin-desktop), [Factory](/runtimes/factory-droid), [Grok Build](/runtimes/grok-build), [Hermes Agent](/runtimes/hermes-agent), [Oh My Pi](/runtimes/oh-my-pi), [OpenCode](/runtimes/opencode), [Pi](/runtimes/pi), and [Qwen Code](/runtimes/qwen-code) hooks and managed plugins are installed separately with [`beacon endpoint hooks`](/cli/hooks), because hooks are per-user or per-project runtime configuration rather than base collector service configuration. |## Integration paths@@ -59,7 +62,10 @@ During install, Beacon configures the runtime surfaces it can safely manage:| [Hermes Agent](/runtimes/hermes-agent) | Shell hook payloads through `beacon-hooks` | Beacon merges user-level Hermes shell hooks and maps prompts, tools, commands, approvals, session lifecycle, and subagent stop metadata into endpoint events. || [OpenCode](/runtimes/opencode) | Managed local plugin through `beacon-hooks` | Plugin invokes Beacon for chat, session, command, permission, diff, and error events where payloads are available. || [Cline](/runtimes/cline) | Managed local plugin through `beacon-hooks` | One plugin covers the VS Code, JetBrains, and CLI hosts; it forwards run and tool hooks for prompt, task lifecycle, tool, command, file, MCP, and token telemetry. |-| [Pi](/runtimes/pi) | Managed local extension through `beacon-hooks` | Pi has no hooks file and no OTLP export, so the TypeScript extension API is the only observation surface. Discovery and harness attribution ship today; the extension itself does not, so no Pi hook events are collected yet. |+| [Pi](/runtimes/pi) | Managed local extension through `beacon-hooks` | Pi has no hooks file and no OTLP export, so the TypeScript extension API is the only observation surface. Beacon's managed extension subscribes to seven Pi event types and forwards session, prompt, tool, command, file, reasoning, and usage telemetry. |+| [Oh My Pi](/runtimes/oh-my-pi) | Managed local extension through `beacon-hooks` | A pi-mono fork that kept Pi's event payload shapes, so the two share one mapper but never share identity: separate harness names, separate extension markers, separate install directories. Unlike Pi it exposes real operator approval decisions, which are recorded as `observed` approvals. |+| [Prime Agent](/runtimes/prime-agent) | Not yet collected | Another pi-mono fork with the same extension API. Harness identity and the plugin collection method ship today; the managed extension, discovery probe, and install target do not, so no Prime Agent events are collected yet. |+| [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. || [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 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. |@@ -71,7 +77,7 @@ During install, Beacon configures the runtime surfaces it can safely manage:## Hook telemetry-Antigravity CLI, Claude Code, Cline, Cursor, Devin CLI, Devin Desktop, Factory, Grok Build, Hermes Agent, OpenCode, Qwen Code, and optional VS Code hooks cover activity that is better represented as runtime events than generic OTLP spans.+Antigravity CLI, Claude Code, Cline, Cursor, Devin CLI, Devin Desktop, Factory, Grok Build, Hermes Agent, Oh My Pi, OpenCode, Pi, Qwen Code, and optional VS Code hooks cover activity that is better represented as runtime events than generic OTLP spans.| Runtime | Hook telemetry ||---------|----------------|@@ -86,6 +92,8 @@ Antigravity CLI, Claude Code, Cline, Cursor, Devin CLI, Devin Desktop, Factory,| [Hermes Agent](/runtimes/hermes-agent) | Session lifecycle, prompt submission, observed tool calls, post-tool command and file activity, approval request and response events, and subagent stop metadata where Hermes exposes payloads. Hermes hooks are user-level only. || [OpenCode](/runtimes/opencode) | Chat messages, session events, command execution, permission activity, diffs, and errors where payloads are available. || [Cline](/runtimes/cline) | Prompt submission, task start and end, task errors, tool invocation and completion, command execution with exit code, file reads and edits with diffs, MCP tool activity, and task token usage. Approval decisions are not exposed by Cline's hook payloads. |+| [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, and MCP tool activity is resolved from Oh My Pi's `mcp__<server>_<tool>` naming. || [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. |Hook events include metadata such as file path, operation, language, diff hash, and diff byte count. Raw diffs are subject to Beacon's redaction, sanitization, truncation, and event-size limits before writing.diff --git a/docs/runtimes/prime-agent.mdx b/docs/runtimes/prime-agent.mdxnew file mode 100644index 00000000..4abe1f72--- /dev/null+++ b/docs/runtimes/prime-agent.mdx@@ -0,0 +1,51 @@+---+title: "Prime Agent"+description: "Asymptote support status for Prime Agent (Prime Intellect) endpoint telemetry"+---++## Runtime overview++[Prime Agent](https://github.com/PrimeIntellect-ai/prime-agent) is Prime Intellect's coding and research harness. Like [Oh My Pi](/runtimes/oh-my-pi), it is a hard fork of [pi-mono](https://github.com/badlogic/pi-mono) and kept its TypeScript extension API, so it fits the same integration shape as [Pi](/runtimes/pi): no hooks configuration file to merge a managed hook block into, and no OpenTelemetry export to point at the local collector.++<Warning>+**Partial support.** Harness identity ships today; collection does not. Asymptote recognizes Prime Agent as its own runtime and resolves every spelling to one canonical harness name, but there is no managed extension, no installer, and no discovery probe yet, so `beacon` collects no Prime Agent telemetry. There is nothing to install for this runtime at present.+</Warning>++## What ships today++| Area | Support |+|------|---------|+| Harness attribution | Supported. `prime`, `prime_agent`, `prime-agent`, `primeagent`, `prime_cli`, `prime-cli`, `prime_intellect`, and `prime-intellect` all normalize to `prime_agent` |+| Collection method | Defined. The `prime` platform is registered as a plugin-shaped integration, so any Prime Agent event carries `harness.collection_method=plugin` rather than defaulting to `hook` |+| Managed extension | Not shipped |+| Discovery and telemetry status | Not shipped. `beacon endpoint discover` does not probe for Prime Agent |+| Install, status, uninstall, repair | Not shipped. `beacon endpoint hooks install --harness prime` is not a supported target |+| Runtime event collection | Not shipped. No prompt, tool, command, file, MCP, reasoning, or token telemetry is collected |++## Why the harness name ships first++`harness.name` is a release contract: dashboards, SIEM queries, and the rule pack group by it, so the name has to be pinned before any events are written under it. Two decisions are already fixed and will not change when collection lands.++**Prime Agent is not Pi.** Recording its sessions as `pi_cli` would merge two separately installed products' activity under one name in every query that groups by harness — the one thing a security log must not do to two different runtimes on the same machine. It gets its own canonical name, as Oh My Pi does, for the same reason.++**Matching is by equality against a closed set, not by substring.** "prime" is an ordinary English word that appears in model ids, file paths, and vendor names, so a substring rule would report any event whose harness attribute merely contained it as a Prime Agent session. Both the hook spelling (`--platform prime`) and the runtime's own name (`prime-agent`) are pinned, so one session cannot be recorded under two names.++## What collection will look like++Prime Agent's observation surface is its extension API, the same one Pi and Oh My Pi expose, so support will follow the same shape those runtimes use: one Asymptote-owned TypeScript extension file, installed at user or project level, forwarding runtime events to the local `beacon-hooks` binary. That is why the platform is already registered as `plugin` rather than left to the `hook` default — a plugin platform reported as `hook` overstates vendor support.++Two things will not change with it. Asymptote will not synthesize approval decisions from a blocking tool handler, matching the [Pi](/runtimes/pi) and [Cline](/runtimes/cline) posture, and enforcement will stay behind the optional, off-by-default policy provider seam (`BEACON_POLICY_PROVIDER`).++## Related++<Columns cols={3}>+ <Card title="Pi" icon="code" href="/runtimes/pi">+ The upstream runtime Prime Agent forked, supported through a managed extension.+ </Card>+ <Card title="Oh My Pi" icon="code" href="/runtimes/oh-my-pi">+ Another pi-mono fork, and the shape Prime Agent support will follow.+ </Card>+ <Card title="Supported agent harnesses" icon="list-check" href="/runtimes">+ Return to the runtime support overview.+ </Card>+</Columns>diff --git a/docs/runtimes/vercel-fx.mdx b/docs/runtimes/vercel-fx.mdxnew file mode 100644index 00000000..58a4ef4d--- /dev/null+++ b/docs/runtimes/vercel-fx.mdx@@ -0,0 +1,138 @@+---+title: "fx (Vercel Labs)"+description: "Asymptote support details for fx (vercel-labs/fx) endpoint telemetry"+---++## Runtime overview++Asymptote supports [fx](https://github.com/vercel-labs/fx), Vercel Labs' native coding agent, by reading the session records fx commits to disk.++fx is the one supported runtime with no third-party observation surface at all. Its lifecycle hooks are Zig handlers compiled into the binary rather than commands a settings file can point at, it ships no OpenTelemetry export, and its plugin story is MCP — which describes the tools fx calls, not what fx did. What it does have is a durable, append-only record of every session under `~/.fx/sessions`, so Asymptote reads that.++```bash+beacon endpoint fx sync+```++<Note>+There is nothing to install into fx and nothing to configure inside it. Collection is an action you run rather than a setting Asymptote writes, which is why fx has a command instead of a `beacon endpoint hooks install --harness` target.+</Note>++## Prerequisites++Before collecting fx telemetry, make sure:++- fx is installed and has run at least once, so `~/.fx/sessions` exists.+- `beacon endpoint install` has run so shared endpoint config and runtime log paths exist.+- Something runs `beacon endpoint fx sync` on a schedule, or leaves `--watch` running. Nothing sweeps on its own.++## Collection path++Every fx event carries `harness.collection_method=poll`. Asymptote sees what a turn did once fx committed it, rather than observing the agent as it works. Stating the consequence plainly: nothing on this path can hold or deny a tool call, and nothing appears in the runtime log until the turn is committed.++| Item | Path |+|------|------|+| fx session store | `~/.fx/sessions/<session>/events.jsonl` |+| fx session manifest | `~/.fx/sessions/<session>/session.json` |+| Collector cursor (user mode) | `~/.beacon/endpoint/state/fx.json` |+| Collector cursor (system mode) | `fx-state.json` beside the system runtime log |++A sweep reads each session's log only as far as the manifest's committed watermark, so a frame fx is still writing is left for the next sweep rather than counted as corruption. The cursor stores both the sequence number and fx's log generation, because fx restarts sequence numbers when it compacts a log; without the generation a compaction would look like a rewind and replay the session.++Re-reading is safe. Each event's dedup id comes from the record's own coordinates — session, log generation, sequence, and position within the turn — not from its content, so the same fx record maps to the same event on every sweep.++fx has no OpenTelemetry export and no hook or plugin file for Asymptote to write, so there is no OTLP path and no managed file for this runtime.++## Discovery and status++Asymptote detects fx through the `fx` executable, and treats `~/.fx` as an additional signal. fx installed through its setup script, a shell alias, or a per-user bin directory is often missing from the `PATH` the endpoint process inherited while its profile directory is still present. The Pi, Oh My Pi, OpenCode, Cursor, and Hermes probes use the same fallback.++```bash title="Show fx discovery state"+beacon endpoint discover --all --json+```++fx reports as the `vercel_fx` harness with capability `session_log`, which no other runtime has. The other capabilities describe something Asymptote writes into the runtime and the runtime then calls; fx offers nothing to write into, so there is no marker to check. That changes what "telemetry enabled" can honestly mean here: the only evidence telemetry is flowing is that a sweep has actually run and is level with the sessions on this machine.++| Telemetry status | Meaning |+|------------------|---------|+| `missing` | fx has written no sessions on this machine, so there is nothing to collect yet |+| `disabled` | Sessions are present and none have been collected; run `beacon endpoint fx sync` |+| `enabled` | Sweeps have collected some or all sessions; the message names how many of how many |+| `misconfigured` | The collector cursor file exists but could not be read |++A session whose manifest cannot be read is reported as not caught up rather than assumed to be, because it cannot say how far fx has committed.++## Install or configuration support++```bash+beacon endpoint fx status # sessions fx has written, and how much of each has been read+beacon endpoint fx sync # one sweep, then exit+beacon endpoint fx sync --print # map records to events without writing or advancing the cursor+beacon endpoint fx sync --watch # sweep continuously+beacon endpoint fx sync --watch --interval 5m+```++See [`beacon endpoint fx`](/cli/endpoint-fx) for the full flag reference.++`--print` is a dry run in both directions: it neither writes the runtime log nor advances the cursor, so running it twice shows the same events and running it does not quietly consume the work a later real sweep would do.++## Telemetry coverage++| Area | Support |+|------|---------|+| Runtime discovery | Supported through executable and profile-directory detection, plus how much of the session store has been collected |+| Harness attribution | Supported. `fx`, `fx_cli`, `fx-cli`, `fx.sh`, `fx_agent`, `vercel_fx`, and `vercel fx` all normalize to `vercel_fx` |+| Configuration and MCP inventory | Supported. `~/.fx/settings.json`, `~/.fx/mcp.json`, and a workspace `.mcp.json` are inventoried as fx's own configuration |+| Session start | Supported. `session.started`, emitted once per session even though fx writes a fresh start record at sequence 1 of every log generation |+| Session context | Supported. `session.context` for a model or provider change and for a workspace rebind, since fx sessions are portable across directories |+| Prompts | Supported. `prompt.submitted`, with the path and media type of any attached images. The event is stamped at the turn's start rather than at commit time, so a prompt does not sort after the tool calls it caused |+| Tool use | Supported. `tool.invoked`, `tool.completed`, and `tool.failed`, joined by `gen_ai.tool.call.id`. A call that was in flight when the user interrupted the turn is recorded too, as a `tool.invoked` with no result |+| Commands | Supported. `command.executed` for fx's `run_command` and `terminal` tools, with the exit status or signal and the captured output |+| File activity | Supported. `file.read`, `file.created`, and `file.modified`, with the diff, its hash, and its byte count on an edit |+| MCP activity | Supported. `mcp.tool_invoked` for calls that went to a connected server. fx's own `mcp_search_tools`, `mcp_select_tool`, and `mcp_features` control tools share the `mcp_` prefix and are excluded, so the prefix stays a reliable signal |+| Agent messages | Supported. `agent.message` when a turn's assistant reply is committed |+| History compaction | Supported. `session.compacting` when fx drops turns from its own history to reclaim context |+| Token usage and cost | Supported. `token.usage` normalized into `gen_ai.usage`, derived per turn from fx's cumulative totals, plus runtime-reported cost |+| Event fidelity | Every event is `observed`. fx's record names the tool, the call id, the file, the action, the exit code, and the diff, so nothing here is derived by keyword match |+| Threat detection | Supported. fx events reach `beacon scan` through the same `command.command` and `file.path` fields the rule pack already matches on |+| Local JSONL and dashboard | Supported. The dashboard labels the harness "fx (Vercel Labs)" |+| MDM deployment | Supported for the endpoint agent. The sweep itself is a command to schedule, not a file to deploy |++## Data handling++fx content is handled like every other runtime. Prompts, assistant replies, tool arguments, commands, command output, paths, and diffs are retained in local or customer-controlled logs, with local secret redaction and per-string limits applied before writing, and a hash and byte count on each content-bearing event. Events over the 64 KiB limit drop raw and retained content, preserve stable metadata, and set `field_truncated`.++The sweep is local and offline. It reads files already on this machine and writes the runtime log; nothing about it reaches the network.++## Known gaps++- **No approvals.** fx persists permission feedback as text rather than a per-call decision, so there is nothing to record as an approval. Asymptote does not synthesize one, matching the [Cline](/runtimes/cline) and [Pi](/runtimes/pi) posture.+- **No session end.** fx sessions are resumable, so there is no point at which fx declares one over. Asymptote does not invent a `session.ended` for a session that may be resumed tomorrow.+- **No enforcement, and none possible on this path.** A poll sees a committed record. Even the optional, off-by-default policy provider seam (`BEACON_POLICY_PROVIDER`) has nothing to attach to here, because the tool call already ran.+- **Events land a turn late.** fx commits a turn when it finishes, so telemetry arrives at turn granularity rather than as the agent works, and no sooner than the next sweep.+- **Nothing sweeps automatically.** `beacon endpoint fx sync` runs when you run it. Schedule it, or leave `--watch` running, or the runtime log stops at the last sweep.+- **Unknown record kinds are skipped by name.** A kind fx adds later is skipped as unknown rather than mistaken for one Asymptote maps, so new fx behavior needs a Beacon update before it appears.++## Deployment notes++Confirm discovery sees the runtime, preview what a sweep would emit, then sweep and check the log:++```bash+/opt/beacon/bin/beacon endpoint discover --all --json+/opt/beacon/bin/beacon endpoint fx status+/opt/beacon/bin/beacon endpoint fx sync --print+/opt/beacon/bin/beacon endpoint fx sync+grep '"name":"vercel_fx"' ~/.beacon/endpoint/logs/runtime.jsonl | tail -3+```++For continuous collection, run the sweep under whatever scheduler the platform already uses — a `launchd` agent, a systemd timer, a Scheduled Task, or a cron entry — or leave `beacon endpoint fx sync --watch` running in the operator's session. The interval floor is 5 seconds; a sweep re-reads each changed session's log, so a very short interval spends real work to shorten a window fx's own commit latency already bounds.++## Related++<Columns cols={2}>+ <Card title="beacon endpoint fx" icon="terminal" href="/cli/endpoint-fx">+ Flags, output, and cursor behavior for the sweep.+ </Card>+ <Card title="Supported agent harnesses" icon="list-check" href="/runtimes">+ Return to the runtime support overview.+ </Card>+</Columns>