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
freshen readme
Justin D'Souza05a43462df68
diff --git a/CLAUDE.md b/CLAUDE.mdindex f68277aa..30d0ab23 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -24,11 +24,11 @@ Do not recreate or depend on removed `asymptote` mirror trees. Keep new work foc- Beacon is visibility-first endpoint telemetry for local AI agent runtimes, not a hosted policy service or general endpoint protection product.- Preserve the local-only default. The public Beacon build must not require a hosted account, remote policy fetch, hosted dashboard, or external network dependency during normal hook execution, and hooks themselves never touch the network.-- Asymptote Managed forwarding (`cli/beacon/internal/endpoint/asymptote`, `beacon endpoint asymptote`) is the one destination that sends telemetry to an Asymptote-run service, and it is an explicit, opt-in, revocable Vector destination shaped like every other pack: Beacon stays the local JSONL producer, Vector does the network, and the per-device key lives in a `0600` secrets file read through Vector's secret backend, never in `config.json`, `vector.toml`, or the process environment. Nothing is forwarded until a member of the organization approves the specific device in the browser; only lines written after that are shipped (`read_from = "end"`); revocation from the dashboard takes effect at the ingest service within a minute. The wire contract (gzip NDJSON to `/v1/ingest/{runtime,inventory}`, bearer `bcn_device_*` key, `/v1/ingest/health` credential check) is owned by the `beacon-ingest` service in beacon-mdr; change both sides together. Do not add a second network channel, and do not let the ingest URL be anything but `https://`. The one exception to the no-environment rule is the cloud-sandbox shuttle (`cli/beacon-hooks/internal/cloudshuttle`, active only when `BEACON_ORIGIN=cloud`, where hooks are the only process): a Claude Code web sandbox has no Vector, no service manager, no browser and no persistent disk, so it ships its runtime log itself, and `BEACON_CLOUD_UPLOAD=asymptote` sends new lines to the same `/v1/ingest/runtime` contract with a device key an operator minted for that environment (`BEACON_CLOUD_DEVICE_KEY`), alongside the existing GCS and S3 targets. It is still `https://`-only, still a `bcn_device_*` key, still revocable from the dashboard, and never used on an endpoint install.-- Two bounded network channels exist, both explicit. The first: `beacon endpoint install` asks for an email and work/personal intent once per machine and POSTs that plus install context (OS, arch, version, install method, detected runtime names, a random install ID) to an Asymptote-run signup endpoint. The same first-run prompt ends with a telemetry destination question (arrow-key picker, local first so Enter forwards nothing): keep it local, forward to the user's own infrastructure (prints the log-forwarding docs URL, nothing else changes), or forward to Asymptote Managed. `BEACON_MANAGED_INGEST=0` hides the Asymptote row; `install --connect` skips the question and connects. Local and own-infrastructure answers are recorded in the profile and never asked again; the Asymptote answer runs `connect` after the install, is recorded only once that connect succeeds so a failed install or connect is asked again rather than remembered as done, and is the only way onboarding ever forwards telemetry. The answer is never sent. The second channel is that forwarder, described below. This is intentional product behavior for open-source attribution, not an oversight — do not remove it. It is strictly bounded: interactive TTY only, once per machine, never during hook execution, never on `--system`/root/CI/piped-stdin/`--dry-run` installs, and always skippable with `BEACON_ONBOARDING=0`. A failed submission never fails an install. No prompt text, telemetry event, file content, or command ever leaves the machine through it. Implementation lives in `cli/beacon/internal/onboarding` and `cli/beacon/cmd/endpoint_onboarding.go`; `docs/cli/endpoint-onboarding.mdx` documents the payload field-by-field, so changing the fields means changing that page too. The README does not describe onboarding at all — do not add a second copy of the field list there.+- Asymptote Managed forwarding (`cli/beacon/internal/endpoint/asymptote`, `beacon endpoint connect`, `beacon endpoint asymptote`) is opt-in and Vector-shaped: Beacon writes local JSONL, Vector ships new lines after browser approval, and the `bcn_device_*` key stays only in `<BaseDir>/asymptote/vector-secrets.json` via Vector's secret backend. Keep the ingest URL `https://`, the wire contract aligned with `beacon-ingest` (`/v1/ingest/{runtime,inventory}` and `/v1/ingest/health`), and do not add another endpoint network channel. The cloud-sandbox shuttle is the bounded exception: only with `BEACON_ORIGIN=cloud`, it can upload new runtime lines to GCS, S3, or the same Asymptote ingest contract because no Vector/service manager/browser/persistent disk exists there.+- `beacon endpoint install` has a bounded onboarding channel for open-source attribution and destination choice. It is interactive TTY only, once per machine, skipped for system/root/CI/piped-stdin/dry-run or `BEACON_ONBOARDING=0`, and failures never fail install. It sends install context only, never prompts, events, file content, or command output. Implementation lives in `cli/beacon/internal/onboarding` and `cli/beacon/cmd/endpoint_onboarding.go`; keep `docs/cli/endpoint-onboarding.mdx` in sync with payload changes and do not copy the field list into the README.- Do not add dependency vulnerability scanning, OSV/GHSA lookups, package remediation, or other vulnerability-enforcement flows to the public hook path.- Do not add broad runtime enforcement unless explicitly requested. Current control behavior is limited to hook-native approvals/denials exposed by supported agent runtimes.-- Keep direct destination support scoped to local JSONL/Wazuh unless explicitly requested. Elastic support is a file-tailing pack over local JSONL; Beacon itself must not store Elastic credentials or require a hosted Elastic dependency.+- Keep destination support shaped like the existing local JSONL and customer-managed forwarding paths. Beacon may render supported packs or token-based endpoint forwarders, but should not add hosted SIEM dependencies or store third-party service credentials beyond the explicit supported configs. Elastic remains a file-tailing pack over local JSONL.- Beacon writes retained prompt text, command output, raw tool inputs, raw OTLP attributes, and raw diffs to local or customer-controlled logs, subject to local redaction and size limits where supported.- The Asymptote Observe TypeScript SDK may default to the hosted `/v1/observe` endpoint as an opt-in cloud SDK contract. Beacon endpoint execution stays local-only/no-network.@@ -36,29 +36,22 @@ Do not recreate or depend on removed `asymptote` mirror trees. Keep new work focSupported runtime surfaces today:-- Claude Code and Codex CLI telemetry configuration through local OpenTelemetry settings. Historical- or missed Codex CLI activity can also be recovered explicitly with `beacon endpoint codex sync`,- which reads Codex's committed rollout files under `~/.codex/sessions` as a poll collection path.- This sync command is local and offline, checkpoints by file path and line number, maps session- metadata, prompts, assistant messages, custom tool calls/results, command executions, task- completion, and top-level `token_usage_record` rows, and never reads `~/.codex/auth.json`. It is- not hook execution and cannot approve, deny, or delay tool calls.+- Claude Code and Codex CLI use local OpenTelemetry settings; Claude/Codex hooks add runtime-native context where configured. `beacon endpoint codex sync` is the offline poll backfill from `~/.codex/sessions`; it never reads `~/.codex/auth.json` and cannot approve, deny, or delay tool calls.- Cursor hook telemetry for sessions, prompt submission, tool use, command execution, MCP-like tool activity, approval decisions, file edits, and agent reasoning (`afterAgentThought` thinking text recorded as `agent.reasoning` events in the OTel GenAI `gen_ai.output.messages` reasoning-part shape) where hook payloads expose those fields.-- Cline hook telemetry through a Beacon-managed local plugin (`~/.cline/plugins/beacon.ts`) covering prompts, task lifecycle, tool lifecycle, commands, file reads/edits with diffs, MCP activity, and task token usage. One plugin serves Cline's VS Code, JetBrains, and CLI hosts; Cline's own OTel export and hosted prompt storage are not used. Approval decisions are not exposed by Cline's hook payloads and are not synthesized.-- Pi hook telemetry through a Beacon-managed local extension (`~/.pi/agent/extensions/beacon.ts`, or `.pi/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, commands including operator `!` commands, file reads/creates/edits with the unified patch, agent reasoning from assistant thinking parts, and token usage/cost. The extension subscribes to seven Pi event types and ignores the streaming and provider internals. Approval decisions are not exposed by Pi's extension API -- its `tool_call` handler can block, but that is an extension deciding rather than an operator being asked -- and are not synthesized, matching the Cline decision.-- Oh My Pi (`omp`) hook telemetry through a Beacon-managed local extension (`~/.omp/agent/extensions/beacon.ts`, or `.omp/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, operator approval decisions, commands including operator `!` and `$` Python commands, file reads/creates/edits with the unified patch, MCP tool activity, agent reasoning, and token usage/cost. Oh My Pi is a fork of pi-mono and kept Pi's event payload shapes, so the two share one mapper (`cli/beacon-hooks/cmd/pi_family.go`) but never share identity: separate harness names, separate extension markers, separate install directories. Unlike Pi and Cline it does expose real operator approval decisions (`tool_approval_requested`/`tool_approval_resolved`), so those are recorded as `observed` approvals rather than withheld -- Beacon still never synthesizes one from a blocking `tool_call` handler. Those events carry no tool arguments, so the extension remembers each `tool_call`'s input by `toolCallId` and attaches it to the approval; without it the approval rules, which all match on `command.command` or `file.path`, could not read Oh My Pi approvals at all. The user-level install path honors `PI_CODING_AGENT_DIR` and `PI_CONFIG_DIR`; the project path is always `.omp/extensions`. `mcp_notification` is deliberately not subscribed to.-- Prime Agent (Prime Intellect) hook telemetry through a Beacon-managed local extension (`~/.prime/agent/extensions/beacon.ts`, or `.prime/agent/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, commands, file edits with the unified patch, agent reasoning, and token usage/cost. Prime Agent is the other hard fork of pi-mono, so it shares the `pi_family.go` mapper with Pi and Oh My Pi and never shares their identity: separate harness name (`prime_agent`), separate extension marker, separate install directory. Its subscription list is Pi's exactly, and that is a finding rather than a copy -- it has no `user_python` (its operator surface is `!` alone) and no approval event at all, so approvals are not synthesized, matching the Pi, Cline and fx decision. What is different is its single-tool design: the only default tool is `ipython`, a persistent Python kernel through which the agent reads files, writes files and runs shell commands via `bash()`, so a cell is recorded as `command.executed` with the code in `command.command` and a Python marker in `raw` -- filing it under `tool.completed` would hide essentially every action the agent took from the command-scoped rules. A cell's result carries its captured streams as `command.output`, the runtime's own duration and status (`ok`/`error`/`aborted`; an interrupted cell is not a failed one), and its exception class; no exit code is invented, because a Python cell has none. The diffs the kernel streams for files it rewrote become one `file.modified` each, built with `FromEditFragments` because the pair is a replaced span rather than the file before and after. Prime Agent also has an offline poll path, `beacon endpoint prime sync`, which reads committed JSONL transcripts under `~/.prime/agent/sessions` plus subagent artifacts under `~/.prime/agent/session-artifacts`, checkpoints by file and line number, and emits `harness.collection_method=poll` events for backfill; it complements the live extension and cannot block or delay tool calls. Two path details are the runtime's own: its config directory name is the two-segment literal `.prime/agent`, joined under the working directory as well as the home directory, so its *project* scope keeps the `agent` segment Pi's and Oh My Pi's drop; and its agent-directory override is `PRIME_AGENT_CODING_AGENT_DIR`, derived from its own package name, so `PI_CODING_AGENT_DIR` is deliberately not honored. MCP is not separately attributed and cannot be: consistent with the single-tool design, Prime Agent does not expose MCP servers as agent tools -- each integration is a Python skill package the model imports and calls from inside the kernel -- so an MCP call arrives as part of a cell's code rather than as an `mcp.tool_invoked` event.-- Senpi (`omo`), the standalone edition of oh-my-openagent (OMO), hook telemetry through a Beacon-managed local extension (`~/.omo/agent/extensions/beacon.ts`, or `.omo/agent/extensions/beacon.ts` at project level) covering session lifecycle, prompts, tool lifecycle and results, commands, file activity with the unified patch, agent reasoning, and token usage/cost. oh-my-openagent ships three editions -- Ultimate (an OpenCode plugin), Light (a Codex CLI plugin), and Senpi (a standalone CLI) -- and only Senpi is a genuinely new, previously-uncaptured runtime: the other two ride hosts Beacon already observes (`opencode`, `codex`), so their activity already flows through those existing integrations rather than needing a fourth editor-specific mapper here. Senpi is itself an in-flight fork of pi-mono (`code-yeongyu/senpi`, upstream `badlogic/pi-mono`) that OMO brands and bundles its own extension into, so it shares the `pi_family.go` mapper with Pi, Oh My Pi and Prime Agent and never shares their identity: separate harness name (`omo_senpi`), separate extension marker, separate install directory. Its subscription list is Pi's exactly -- it kept pi-mono's ordinary `bash`/`read`/`edit`/`write`/`grep`/`find`/`ls` tool set rather than Prime Agent's single-kernel design, so its telemetry shape looks like Pi's and Oh My Pi's rather than Prime Agent's. It has no `user_python` and no approval event at all -- its `tool_call` handler can block, but that is an extension deciding, and its permission-system builtin owns the real approval prompt without publishing it as an extension event -- so approvals are not synthesized, matching the Pi, Prime Agent and Cline decision. Senpi's own `ExtensionEvent` surface is larger than Pi's (`tool_execution_start`/`tool_execution_end`, `turn_start`/`turn_end`, `agent_start`/`agent_end`/`agent_settled`, `model_select`, and more), but none of those additions describe an agent action `tool_call`/`tool_result` do not already cover, so they are deliberately left unsubscribed rather than adding a second, thinner tool-lifecycle signal beside the one already recorded for every Pi-family runtime. Two path details are the runtime's own: its config directory name for this brand is `.omo`, and its own directory resolver joins the `agent` segment under the working directory as well as the home directory, so its *project* scope keeps the segment Pi's and Oh My Pi's drop, the same shape Prime Agent uses; and its agent-directory override is `OMO_CODING_AGENT_DIR`, falling back to the legacy `SENPI_CODING_AGENT_DIR` and then `PI_CODING_AGENT_DIR` in the same order Senpi's own brand profile reads them, rather than only the newest of the three. The harness name is `omo_senpi` rather than bare `omo` because OMO's other two editions exist and are not observed through this extension; `NormalizeHarnessName` deliberately keeps bare `senpi` and `oh-my-openagent` unmapped for the same reason -- plain Senpi is a separately installable engine, and `oh-my-openagent` also names the OpenCode and Codex CLI editions.-- OpenCode telemetry has two paths. The live path is still the Beacon-managed plugin (`plugins/opencode-beacon`, installed as `~/.config/opencode/plugins/beacon.ts` or project `.opencode/plugins/beacon.ts`) and is the only path that observes permission requests/replies, live session boundaries, and hook timing. The poll path is `beacon endpoint opencode sync` (`cli/beacon/internal/opencodesession`, `cli/beacon/cmd/endpoint_opencode.go`), which reads OpenCode's committed local store after the fact: current `opencode.db` tables (`session`, `message`, `part`) when present, and the legacy `storage/session`, `storage/message`, `storage/part`, `storage/project` tree otherwise. It backfills historical and uninstrumented sessions into endpoint events marked `harness.collection_method=poll`, covering prompts, assistant text/reasoning, completed or failed tool outcomes, commands, file activity when a persisted path exists, compaction parts, and token usage/cost where OpenCode persisted it. It cannot hold or deny tools and must not synthesize approvals from persisted tool results; the live plugin remains the source for approval telemetry. The cursor lives outside OpenCode under Beacon endpoint state as `opencode-sessions.json`, keyed separately by SQLite versus legacy source, and `--print` must not advance it.-- Muse Code (Meta) hook telemetry through a Beacon-owned managed hooks file (`$XDG_CONFIG_HOME/muse/beacon-endpoint-hooks.json`, else `~/.config/muse/...`) that Muse's own `settings.json` points at with the `managed_hooks_path` key. Covers session start, prompts, tool lifecycle, operator approval decisions from `PermissionRequest`, subagent start/stop, context compaction, commands, and file activity. Muse Spark is the model and Muse Code is the agent: the harness is `muse_code`, and Muse Spark spellings are deliberately unmapped in `NormalizeHarnessName` so a model id cannot masquerade as the runtime. `PreLLMCall`/`PostLLMCall` are deliberately not subscribed to -- both carry the full `messages` array and tool schemas on every model call, and `PostLLMCall` fires per response chunk. Not collected, because Muse exposes none of it on a hook: token usage/cost, a session-end event, and subagent-to-parent correlation. Muse publishes no hook API, so the contract is reverse-engineered from a shipped build and a bad hooks file is rejected in total silence -- which is why the installer's emitted shape and the payload readers are both pinned by tests. Implementation lives in `cli/beacon/internal/endpoint/hooks/muse.go` and the `muse` platform branches in `cli/beacon-hooks/cmd`.-- OpenHands (All Hands) hook telemetry through the runtime's own `.openhands/hooks.json`, which Beacon merges its six commands into rather than owning. Covers session start and end, prompts, pre-tool and post-tool activity, commands with exit code and output, file reads and edits, MCP tool calls, and failed tools. The harness is `openhands`; OpenHands LM spellings are deliberately unmapped in `NormalizeHarnessName` so a model id cannot masquerade as the runtime. OpenHands rides the shared hook subcommands rather than getting a mapper of its own, because its six events line up one for one with them; the runtime-specific readers live in `cli/beacon-hooks/cmd/openhands.go` and the installer in `cli/beacon/internal/endpoint/hooks/openhands.go`. File diffs come from the observation's `old_content`/`new_content` rather than from the edit instruction, so they describe what landed on disk; one `apply_patch` call becomes one `file.modified` per changed file. Approval decisions are not exposed by OpenHands' hooks and are not synthesized, matching the Cline, Pi and fx decision. Not collected, because OpenHands exposes none of it on a hook: token usage and cost, a per-call tool id, and assistant response text. The verbatim payload is deliberately not retained under `raw`: its only unhoused field is `metadata`, which is empty on five of six events and constant on the sixth. `hooks.json` has a closed schema that rejects silently -- unknown top-level keys are fatal, a legacy `{"hooks": {...}}` wrapper replaces the whole document, and naming one event in both snake_case and PascalCase takes the file down -- so the installer refuses a file that already breaks one of those, and both the emitted shape and the payload readers are pinned by tests. Both scopes are real, but project scope is the one every host reads: the loader takes the first hooks file it finds rather than merging, and the agent server behind the CLI and the GUI reads only the project file.-- Kiro (AWS) hook telemetry through a Beacon-owned hook file in the directory Kiro scans (`.kiro/hooks/beacon-endpoint.json` at project scope, `$KIRO_HOME`/`~/.kiro/hooks/` at user scope). Covers session start, prompts, pre-tool and post-tool activity, commands with output, file reads and edits, MCP tool calls, failed tools, and the agent's final response from `Stop`'s `assistant_response` as an `agent.message`. The harness is `kiro` -- one name for the IDE and the CLI, because they are one harness reading one hooks directory. Kiro rides the shared hook subcommands: its envelope is spelled exactly as Claude Code's (`hook_event_name`, `cwd`, `session_id`, `tool_name`, `tool_input`, `tool_response`, `prompt`), so `cli/beacon-hooks/cmd/kiro.go` holds no envelope readers at all -- only the tool taxonomy, the `operations`-array path reader, MCP `@server/tool` detection, and the write-`command` guard. Kiro publishes its tool names and not its tool argument schemas, so classification is keyed on names and the diff builder reads both the Amazon Q lineage spellings (`file_text`, `old_str`, `new_str`) and the ecosystem ones, returning no diff rather than a wrong one when neither resolves. Two contract details are load-bearing and easy to get wrong: hook stdout is *added to the agent's context* on `SessionStart` and `UserPromptSubmit`, so Beacon writes nothing to stdout on this platform (`hookStdoutIsConsumedAsAgentContext`); and a block is exit code 2 with the reason on stderr rather than a JSON object, which is why the policy seam's deny is a `policyDenial` carrying an exit code. Timeouts are seconds and `0` means no timeout at all, so every trigger carries an explicit value. Beacon owns one filename in a directory Kiro loads whole, so the installer never reads another file and refuses rather than overwriting one it did not write. Approval decisions are not exposed by Kiro's hooks and are not synthesized -- Kiro does ask the operator through `permissions.yaml` and a trust picker, and `PreToolUse` fires identically whether or not it will, so an inferred approval would claim a decision precisely where none was made. Not subscribed to: `PostFileCreate`/`PostFileSave`/`PostFileDelete`, which duplicate `PostToolUse` for the same write; `PreTaskExec`/`PostTaskExec`, whose stdin payload Kiro does not document; and `Manual`. Not collected, because Kiro exposes none of it on a hook: token usage and cost, a per-call tool id, and a session-end event. Implementation lives in `cli/beacon-hooks/cmd/kiro.go` and `cli/beacon/internal/endpoint/hooks/kiro.go`.-- goose (Block) telemetry over two paths that are collected together because neither is sufficient alone. The hook path is a Beacon-owned plugin: goose discovers plugins as the immediate subdirectories of `.agents/plugins` (user scope honours `GOOSE_PATH_ROOT`; project scope is always `<project>/.agents/plugins`) and loads `<plugin-root>/hooks/hooks.json` from each, so Beacon owns the directory `beacon-endpoint` rather than a file. Seven of goose's twelve events are subscribed to -- `SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `PostToolUseFailure`, `Stop`, `SessionEnd` -- covering session lifecycle, prompts, tool lifecycle, command lines, file creates and edits with diffs, and MCP tool calls. The OTLP path configures `otel_exporter_otlp_endpoint` in goose's own `config.yaml` and carries what no hook does: token usage including cache reads and writes, model and provider, response ids, finish reasons and agent reasoning, on OTel GenAI semconv `chat` and `execute_tool` spans the collector exporter already reads. The harness is `goose`; GooseAI spellings are deliberately unmapped in `NormalizeHarnessName` and unaccepted as targets, because that is a different company's inference service rather than this runtime. Four contract details are load-bearing. goose classifies a *blocking* hook's stdout, so `PreToolUse` and `Stop` must answer `{"decision":"allow"}` -- the `{}` every other runtime reads as no opinion is classified a failed hook, and on a rule configured `on_failure: block` it denies the tool call; the policy seam's deny is correspondingly `{"decision":"block"}`, because goose does not recognise "deny" and would read it as no verdict and allow. `developer` is registered with `unprefixed_tools`, so its tools arrive as bare `shell`, `write`, `edit`, `tree`, `read_image`, and MCP tools are identified only by their `<extension>__<tool>` prefix not naming a built-in extension -- there is no `mcp` in the name, no `mcp_*` argument and no result to inspect. `PostToolUseFailure` carries a payload identical to `PostToolUse`, so the `event` field is the only thing separating a write that landed from one that did not, and it is what the diff guard turns on. And goose exports OTLP over HTTP only, so it takes the collector's HTTP port where Claude Code, Codex and Gemini take gRPC; pointing it at 4317 fails silently. `BeforeShellExecution`, `AfterShellExecution`, `BeforeReadFile` and `AfterFileEdit` are deliberately not subscribed to -- each duplicates `PreToolUse`/`PostToolUse` for the same call and carries no `tool_call_id` -- and `PreToolUseResult` is deferred because it fires once per call to report an outcome that is almost always "allow". Not collected, because goose exposes none of it on a hook: tool output of any kind (so no command exit codes, no command output, no file-read contents), reported cost, and approval decisions -- goose does ask the operator through `ToolApprovalOperation`, exposes none of it, and its `PreToolUse` chain is a separate plugin-policy layer that runs after the operator's decision, so an approval derived from it would claim a decision precisely where Beacon cannot see one. `.agents/plugins` is the shared Open Plugins directory rather than goose's own namespace, so another host implementing that specification would also run these hooks and Beacon could not tell from the payload; that is a stated limitation with no fix on Beacon's side. **Only the adapter half of this is implemented.** `cli/beacon-hooks/cmd/goose.go` maps the payloads and `NormalizeHarnessName` pins the name, so a `hooks.json` that invokes `beacon-hooks --platform goose` is collected correctly today. There is no installer: `goose` is not an accepted `beacon endpoint hooks install --harness` target, there is no `cli/beacon/internal/endpoint/hooks/goose.go`, and no `harness.DiscoverGoose` configures `otel_exporter_otlp_endpoint` in goose's `config.yaml`. Both files must be written by hand. `docs/runtimes/goose.mdx` and the README runtime table both describe the install commands as if they shipped; they have not. Close that gap before treating goose as a supported install target.-- DeepSeek Harness (`dsh`) hook telemetry through `@deepseek-ai/dsh-hooks-claude-code`, the Claude Code hook bridge DeepSeek ships as a dependency of the CLI but does not mount. Covers session start, prompts, pre-tool and post-tool activity, commands with output and exit code, file reads/creates/edits with diffs, MCP tool calls, subagent start/stop, and the turn-closing `Stop`. The harness is `deepseek_harness`; `dsh` is the `--platform` value, and bare `deepseek` plus every DeepSeek model spelling are deliberately unmapped in `NormalizeHarnessName` so a vendor or model id cannot masquerade as the runtime. The envelope is Claude Code's field for field and MCP tools are `mcp__server__tool`, so dsh rides the shared hook subcommands and `cli/beacon-hooks/cmd/dsh.go` holds no envelope or MCP reader -- only the tool taxonomy, the `str_replace_editor` multiplexed-`command` guard, `terminal_send`'s `text` command line, and the `[exit code: N]` marker that is the only place an exit status reaches a hook (the bridge flattens a tool result to text, so `tool_response` is a string). `run_code` is `tool.invoked` rather than `command.executed`: dsh dispatches a program's nested tool calls back through the guarded pipeline, so each fires its own hooks with a real command line, and a TypeScript program in `command.command` would match shell rules on its comments instead. dsh is in `rawPayloadKeys` largely for that tool, since non-MCP tool arguments reach no schema field. Installing takes two files, which is unique to this runtime: a hooks file Beacon owns at `$DSH_HOME/beacon-endpoint-hooks.json`, and one row in `$DSH_HOME/cordis.patch.yml` -- the user's own patch layer, edited as a yaml.Node document so comments, quoting and `!!js` tags survive. An empty patch file fails dsh boot, so an uninstall that would empty it removes it. There is no project scope: the bridge's `configPath` is process-level, so `--level project` is refused. Approval decisions are not exposed by the bridge (it supports seven events and `PermissionRequest` is not among them) and are not synthesized, matching the Cline, Pi, fx, OpenHands and Kiro decision. Not collected, because the bridge exposes none of it: token usage and cost, a session-end event, a per-tool error flag, compaction, and parent-session correlation for a subagent. Implementation lives in `cli/beacon-hooks/cmd/dsh.go` and `cli/beacon/internal/endpoint/hooks/dsh.go` plus `dsh_patch.go`.+- Cline uses a Beacon-managed plugin (`~/.cline/plugins/beacon.ts`) for live capture plus `beacon endpoint cline sync` for local history backfill. Cline's own OTel export/hosted prompt storage are not used, and approvals are not exposed or synthesized.+- Pi-family runtimes use Beacon-managed extensions and the shared `cli/beacon-hooks/cmd/pi_family.go` mapper while keeping separate harness names and install roots: Pi (`pi_cli`), Oh My Pi (`omp`), Prime Agent (`prime_agent`), and Senpi/OMO (`omo_senpi`). Pi, Prime, and Senpi do not expose operator approval decisions, so Beacon does not synthesize them. Oh My Pi exposes real approval events and the extension carries the remembered tool input onto those approvals.+- Prime Agent is the Pi-family exception with a single persistent `ipython` tool: kernel cells are recorded as `command.executed`, carry Python status/output metadata, and have no invented exit code. MCP is not separately attributed because Prime exposes integrations inside the kernel. `beacon endpoint prime sync` is the local poll backfill from `~/.prime/agent/sessions` and session artifacts.+- Senpi is the standalone OMO edition. The OpenCode and Codex editions ride existing Beacon integrations, so do not alias bare `oh-my-openagent` to this extension. The install target is `omo`; the event harness is `omo_senpi`; agent-directory overrides follow OMO's own order (`OMO_CODING_AGENT_DIR`, `SENPI_CODING_AGENT_DIR`, then `PI_CODING_AGENT_DIR`).+- OpenCode uses the managed plugin for live capture and approvals, plus `beacon endpoint opencode sync` for current SQLite and legacy file-store backfill. Poll events are marked `harness.collection_method=poll`, cannot hold or deny tools, and must not synthesize approvals from persisted tool results.+- Muse Code uses a Beacon-owned hooks file referenced by Muse `settings.json` via `managed_hooks_path`. Muse Spark is the model, not the runtime; do not normalize Spark spellings to `muse_code`. `PreLLMCall`/`PostLLMCall` stay unsubscribed because they carry full message arrays/tool schemas and chunked responses.+- OpenHands hooks are merged into the runtime's own `.openhands/hooks.json`. Project scope is the practical default because the loader takes the first hooks file and the CLI/GUI agent server reads the repository file. Approvals, token usage/cost, per-call tool ids, and assistant response text are not exposed or synthesized.+- Kiro uses one Beacon-owned hook file under `.kiro/hooks` or `$KIRO_HOME`/`~/.kiro/hooks`. Its hook stdout is added to agent context on `SessionStart` and `UserPromptSubmit`, so Beacon writes nothing to stdout on Kiro; blocking is exit code 2 with the reason on stderr. Approvals are not exposed or synthesized.+- goose currently has only the adapter: `cli/beacon-hooks/cmd/goose.go` can map a manually written `hooks.json` that invokes `beacon-hooks --platform goose`, but there is no `beacon endpoint hooks install --harness goose`, no `DiscoverGoose`, and no automatic OTLP configuration. Keep README/docs from implying goose is generally installable until those pieces exist. goose uses HTTP OTLP (4318), its blocking hook stdout must be `{"decision":"allow"}` or `{"decision":"block"}`, and it exposes no approval decisions or tool output.+- DeepSeek Harness (`dsh`) is installed through two user-level files: `$DSH_HOME/beacon-endpoint-hooks.json` and a row in `$DSH_HOME/cordis.patch.yml`; there is no project scope. It rides the Claude-shaped envelope, but `run_code` remains `tool.invoked` because nested commands fire their own hooks.- fx (vercel-labs/fx) telemetry read from the session store fx commits under `~/.fx/sessions/`, covering session start, prompts, tool calls, commands with exit codes and output, file reads/creates/edits with diffs, MCP tool calls, agent messages, history compaction, and per-turn token usage plus reported cost. fx exposes no third-party hook, plugin, or OTLP surface -- its lifecycle hooks are compiled into the binary -- so collection is a read of fx's own records, run by `beacon endpoint fx sync`. Every event carries `harness.collection_method=poll`; approvals are not synthesized (fx persists permission feedback text, not a per-call decision, matching the Cline and Pi posture) and no session-end event is invented, since fx sessions are resumable. Implementation lives in `cli/beacon/internal/fxsession` and `cli/beacon/cmd/endpoint_fx.go`.- Claude Cowork admin-configured OpenTelemetry setup guidance and local validation.-- OpenClaw Gateway telemetry over two paths, collected together because neither is sufficient alone. The plugin path is a Beacon-managed plugin: OpenClaw discovers a plugin as the *directory* `beacon-endpoint` under an extensions root (user scope honours `OPENCLAW_STATE_DIR`; project scope is always `<workspace>/.openclaw/extensions`), holding three files -- a plain-JavaScript entry plus the `package.json` and `openclaw.plugin.json` that declare it, with the entry named under both `openclaw.extensions` and `openclaw.runtimeExtensions` so either host build reaches it. Ten of OpenClaw's forty-one typed hooks are registered, covering session lifecycle and resume, prompts, tool lifecycle, commands with exit code and output, file reads/creates/edits with diffs, `apply_patch` as one `file.modified` per changed path, MCP tool calls, compaction, subagent lifecycle, and token usage including cache reads and writes. The OTLP path is OpenClaw's own `diagnostics-otel` plugin, configured *inside OpenClaw* and only printed by `beacon endpoint integrations openclaw` (`cli/beacon/internal/endpoint/integrations/openclaw`); it carries gateway traces and metrics, and by OpenClaw's default carries no content at all. Both paths report the harness `openclaw_gateway`. Five contract details are load-bearing. OpenClaw registers `before_tool_call` **fail-closed**, so a handler that throws or exceeds its timeout blocks the tool call -- that handler therefore dispatches and returns synchronously with no promise to await, which costs event ordering and nothing else, since `gen_ai.tool.call.id` is the join. Conversation hooks, `llm_output` among them, are withheld from every non-bundled plugin until `plugins.entries.beacon-endpoint.hooks.allowConversationAccess` is set, so an otherwise perfect install collects everything except tokens and agent messages. Beacon reads OpenClaw's config and never writes it -- it is JSON *or JSON5*, and a Go round trip would strip an operator's comments out of the file configuring every chat channel they run -- so the installer prints advice instead, and only mentions `plugins.allow` when that key already exists, because introducing an allowlist would deny every other plugin. MCP tools are named `<server>__<tool>` with no `mcp` anywhere, so the separator is the only signal, as on goose. And `derivedPaths` arrives only on `before_tool_call`, so the plugin carries it forward by `toolCallId` -- without it an `apply_patch` is an opaque blob with no file rows. The prompt is `message_received`, the inbound chat message, not `llm_input`'s assembled prompt. Approval decisions are not exposed by OpenClaw's plugin hooks and are not synthesized, matching the Cline, Pi, goose, OpenHands and Kiro decision; the trap is that an `exec` result's `details.approvalReviewOutcome` reads like one and is a *model-backed* review, so it stays in `raw`. Not collected: reported cost (OpenClaw computes it from an operator-configured table rather than a provider report), and gateway lifecycle. Deliberately not registered: the prompt-injection, claim, gate and evaluate hooks, which would give Beacon power over the agent; `llm_input` and `agent_end`, which carry the whole conversation per call; and the two synchronous persistence hooks, which ignore promises. Implementation lives in `plugins/openclaw-beacon`, `cli/beacon-hooks/cmd/openclaw_event.go` and `cli/beacon/internal/endpoint/hooks/openclaw.go`.-- Runtimes that ride the shared hook and OTLP paths without a contract worth writing down here: Antigravity CLI, Devin CLI, Devin Desktop, Factory Droid, Gemini CLI, GitHub Copilot CLI, Grok Build, Hermes Agent, Qwen Code, and VS Code. The bullets above are the runtimes with a reverse-engineered or otherwise surprising contract, not the full supported set — `harness.DiscoverAll` in `cli/beacon/internal/endpoint/harness` and the install switch in `cli/beacon/cmd/endpoint_hooks.go` are the authoritative lists.+- OpenClaw Gateway uses a Beacon-managed plugin directory plus OpenClaw's own diagnostics OTLP guidance (`beacon endpoint integrations openclaw`). The plugin's `before_tool_call` hook is fail-closed, so the handler dispatches synchronously and returns without awaiting. Conversation hooks, including `llm_output`, require `plugins.entries.beacon-endpoint.hooks.allowConversationAccess`; without it, token and agent-message coverage is partial. Beacon reads OpenClaw JSON/JSON5 config for advice but does not rewrite it.+- Runtimes that ride shared hook/OTLP paths without a special contract worth expanding here include Antigravity CLI, Devin CLI, Devin Desktop, Factory Droid, Gemini CLI, GitHub Copilot CLI, Grok Build, Hermes Agent, Qwen Code, and VS Code. Installed hook/endpoint support is governed by `cli/beacon/cmd/endpoint_targets.go` plus the install/status switches in `cli/beacon/cmd/endpoint_hooks.go`; discovery rows live in `cli/beacon/internal/endpoint/harness`.- Browser chat telemetry through an optional Chrome MV3 extension (`browser-extension/`) covering claude.ai and chatgpt.com. A main-world interceptor tees the streamed response, a per-site adapter parses it into a normalized turn, and the service worker POSTs OTLP GenAI logs to the local collector on `127.0.0.1:4318`; the extension never writes files and never contacts a remote endpoint. `harness.name` resolves to `claude_web` or `chatgpt_web` (already handled by `NormalizeHarnessName` in `pkg/asymptoteobserve/harness.go`, where the browser cases must stay above the generic `claude` rule) and `harness.collection_method` is `otlp`. Scope is deliberately narrow: only those origins' chat streams, never other tabs or general browsing. Retention defaults to `full`, so prompt and response text is retained by default; this is documented rather than defaulted down, because browser chat telemetry without content has no investigative value. Treat the adapters as experimental, since both sites' stream formats are private and undocumented.- `beaconjson` OpenTelemetry Collector exporter that converts OTLP logs, traces, metrics, and resource attributes into Beacon endpoint JSONL.- Endpoint inventory (`inventory.heartbeat` / `inventory.snapshot` in `inventory_state.jsonl`) is written by a scheduled job, `com.beacon.endpoint.inventory` (`service.InventoryManager`, user LaunchAgent or system LaunchDaemon, `beacon-inventory.timer` on systemd), every six hours and once at load, on by default and reconciled by `lifecycle.ReconcileInventoryJob` on every install, repair and package upgrade (`beacon endpoint inventory install-daemon`). Agent hooks do not trigger inventory any more; the hook binary's `--cli` flag and `inventory-heartbeat` subcommand survive only as no-ops for hook commands written by older versions, and `beacon endpoint inventory heartbeat --trigger hook` is likewise retired. A system-mode run inventories the active console user's home and still writes the liveness heartbeat when nobody is logged in; the scheduled scan has no working directory, so project-scoped config is only in `beacon endpoint inventory`.diff --git a/README.md b/README.mdindex 88c403ab..4c88e022 100644--- a/README.md+++ b/README.md@@ -46,7 +46,7 @@ activity into a [single, unified schema](https://docs.asymptotelabs.ai/cli/event| Capability | What it means || --- | --- |-| **Broad runtime coverage** | [24 local agent runtimes](#local-agents), plus [browser chat, CI, cloud agents, and SDKs](#supported-surfaces) |+| **Broad runtime coverage** | [Local agent runtimes](#local-agents), plus [browser chat, CI, cloud agents, and SDKs](#supported-surfaces) || **One unified schema** | Every session, prompt, tool, command, edit, approval, and token in one event model || **Local-first by default** | Data stays on the machine: durable JSONL and a read-only [dashboard](https://docs.asymptotelabs.ai/cli/dashboard), no account || **Offline threat detection** | `beacon scan` runs open [Threat Rules](spec/threat-rules/SPEC.md) over your logs, with no network |@@ -159,31 +159,33 @@ for the full breakdown by surface.| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/claude-code.png" alt="" width="16"> | [Claude Code](https://docs.asymptotelabs.ai/cli/supported-runtimes-claude-code) | OTLP + hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/claude-code.png" alt="" width="16"> | [Claude Cowork](https://docs.asymptotelabs.ai/cli/supported-runtimes-claude-cowork) | OTLP | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/cline.png" alt="" width="16"> | [Cline](https://docs.asymptotelabs.ai/cli/supported-runtimes-cline) | Plugin + poll | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | ✅ |-| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/codex.png" alt="" width="16"> | [Codex CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-codex-cli) | OTLP + hook | ✅ | ✅ | ✅ | ✅ | – | ✅ | – | ✅ |+| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/codex.png" alt="" width="16"> | [Codex CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-codex-cli) | OTLP + hooks + poll | ✅ | ✅ | ✅ | ✅ | – | ✅ | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/codex.png" alt="" width="16"> | [Codex Desktop](https://docs.asymptotelabs.ai/cli/supported-runtimes-codex-cli) | OTLP | ✅ | ✅ | ✅ | ✅ | – | ✅ | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/cursor.png" alt="" width="16"> | [Cursor](https://docs.asymptotelabs.ai/cli/supported-runtimes-cursor) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – || <img src="https://www.google.com/s2/favicons?domain=deepseek.com&sz=32" alt="" width="16"> | [DeepSeek Harness](https://docs.asymptotelabs.ai/runtimes/deepseek-harness) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/devin.png" alt="" width="16"> | [Devin CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-devin) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/devin.png" alt="" width="16"> | [Devin Desktop](https://docs.asymptotelabs.ai/cli/supported-runtimes-devin-desktop) | Hooks | – | ✅ | ✅ | ✅ | ✅ | – | ✅ | – |-| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/factory.png" alt="" width="16"> | [Factory Droid](https://docs.asymptotelabs.ai/cli/supported-runtimes-factory-droid) | OTLP + hooks + session sync | ✅ | ✅ | ✅ | – | ✅ | ✅ | – | – |+| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/factory.png" alt="" width="16"> | [Factory Droid](https://docs.asymptotelabs.ai/cli/supported-runtimes-factory-droid) | OTLP + hooks + poll | ✅ | ✅ | ✅ | – | ✅ | ✅ | – | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/vercel-fx.png" alt="" width="16"> | [fx (Vercel Labs)](https://docs.asymptotelabs.ai/runtimes/vercel-fx) | Poll | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | ✅ || <img src="https://www.google.com/s2/favicons?domain=gemini.google.com&sz=32" alt="" width="16"> | [Gemini CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-gemini-cli) | OTLP | – | ✅ | ✅ | – | ✅ | ✅ | ✅ | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/github-copilot.png" alt="" width="16"> | [GitHub Copilot CLI](https://docs.asymptotelabs.ai/cli/supported-runtimes-github-copilot-cli) | OTLP | ✅ | ✅ | ✅ | – | – | ✅ | – | – |-| <img src="https://www.google.com/s2/favicons?domain=block.xyz&sz=32" alt="" width="16"> | [goose](https://docs.asymptotelabs.ai/runtimes/goose) | Plugin + OTLP | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | ✅ |+| <img src="https://www.google.com/s2/favicons?domain=block.xyz&sz=32" alt="" width="16"> | goose | Adapter only; manual hooks/OTLP | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/grok-build.png" alt="" width="16"> | [Grok Build](https://docs.asymptotelabs.ai/cli/supported-runtimes-grok-build) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | – |-| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/hermes-agent.png" alt="" width="16"> | [Hermes Agent](https://docs.asymptotelabs.ai/cli/supported-runtimes-hermes-agent) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – | – |+| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/hermes-agent.png" alt="" width="16"> | [Hermes Agent](https://docs.asymptotelabs.ai/cli/supported-runtimes-hermes-agent) | Hooks + poll | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/kiro.png" alt="" width="16"> | [Kiro](https://docs.asymptotelabs.ai/runtimes/kiro) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/muse-code.png" alt="" width="16"> | [Muse Code](https://docs.asymptotelabs.ai/runtimes/muse-code) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – | – || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/omp.png" alt="" width="16"> | [Oh My Pi](https://docs.asymptotelabs.ai/runtimes/oh-my-pi) | Extension | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/openclaw.png" alt="" width="16"> | [OpenClaw Gateway](https://docs.asymptotelabs.ai/runtimes/openclaw-gateway) | Plugin + OTLP | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | ~ |-| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/opencode.png" alt="" width="16"> | [OpenCode](https://docs.asymptotelabs.ai/runtimes/opencode) | Plugin + Poll | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |+| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/opencode.png" alt="" width="16"> | [OpenCode](https://docs.asymptotelabs.ai/runtimes/opencode) | Plugin + poll | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/openhands.png" alt="" width="16"> | [OpenHands](https://docs.asymptotelabs.ai/runtimes/openhands) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | – | ✅ | – |-| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/pi-agent.png" alt="" width="16"> | [Pi](https://docs.asymptotelabs.ai/runtimes/pi) | Extension + Poll | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ |-| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/prime-agent.png" alt="" width="16"> | [Prime Agent](https://docs.asymptotelabs.ai/runtimes/prime-agent) | Extension | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ |+| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/pi-agent.png" alt="" width="16"> | [Pi](https://docs.asymptotelabs.ai/runtimes/pi) | Extension + poll | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ |+| <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/prime-agent.png" alt="" width="16"> | [Prime Agent](https://docs.asymptotelabs.ai/runtimes/prime-agent) | Extension + poll | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/qwen-code.png" alt="" width="16"> | [Qwen Code](https://docs.asymptotelabs.ai/runtimes/qwen-code) | Hooks | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | – | – || <img src="https://www.google.com/s2/favicons?domain=github.com&sz=32" alt="" width="16"> | [Senpi](https://docs.asymptotelabs.ai/runtimes/senpi) | Extension | ✅ | ✅ | ✅ | ✅ | ✅ | – | – | ✅ || <img src="cli/beacon/internal/endpoint/dashboard/static/runtime-logos/visual-studio-code.png" alt="" width="16"> | [VS Code](https://docs.asymptotelabs.ai/cli/supported-runtimes-vscode) | OTLP + hooks | ✅ | ✅ | ✅ | ~ | ~ | – | ~ | – |+goose currently has a tested hook adapter, but no Beacon installer, discovery row, or automatic OTLP configuration. Use it only by writing the goose hook and OTLP configuration manually.+#### Browser Chat| Logo | Site | Collection | Prompt | Response | Tool | Tokens |