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
Leave Claude Cowork events unattributed under peer attribution
Claudea513e706b394
diff --git a/CLAUDE.md b/CLAUDE.mdindex 3084c294..e4cfafd0 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -59,7 +59,7 @@ Supported runtime surfaces today:- 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. The `@deepseek-ai/dsh-hooks-claude-code` bridge that row mounts is not shipped with the CLI (dev dependency only) and must be installed per profile with `@deepseek-ai/dsh-hook-protocol` at exactly the dsh version; a mount dsh cannot load is skipped at boot with only a warning. So `InstallDsh` first runs `hooks.InspectDshBridge` (`internal/endpoint/hooks/dsh_bridge.go`, read-only: the installation found from the `dsh` launcher on PATH, each `$DSH_HOME/profiles/*` resolved Node-style, and rows in any patch layer that mount a bridge by absolute path at Beacon's hooks file) and returns `*DshBridgeUnavailableError` without writing anything when nothing loads a matching bridge; explicit `--harness dsh` fails, `--all` and endpoint install skip with a warning. A healthy by-path mount (how Nix installs it; it must also resolve its declared dsh peers from its own location, because dsh's host-package interception applies only to profile plugins, else `peers_missing`) counts as installed and Beacon writes no row of its own (removing one it wrote earlier) so hooks never run twice. Beacon never installs the packages. `DshStatus.Active`/`Bridge`, discovery (misconfigured when inactive), doctor `dsh_hook_bridge`, and inventory (each profile's patch layer) surface it; tests build on-disk fixtures with `internal/endpoint/hooks/dshtest`. It also installs a Beacon-owned local skill at `$DSH_HOME/skills/beacon-endpoint/SKILL.md` and supports native session backfill from `$DSH_HOME/sessions` through `beacon endpoint dsh sync`, which fills assistant text/reasoning, tool failures, and token usage that the hook bridge does not expose. It rides the Claude-shaped envelope on the hook path, 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`.- Harness² (google-research/harness2) rollouts, read from the executor event streams Harness² records under its runs directory (`$HARNESS2_RUNS_DIR`, `~/harness2/runs`, or a `--runs-dir` an earlier sync was given and the cursor file remembers): OpenCode `run --format json` and Codex `exec --json`, recognized by their first event rather than by file name. Harness² runs Codex under its own `CODEX_HOME` with `--ephemeral` and OpenCode from a source checkout, so Beacon's Codex/OpenCode integrations do not record these sessions. Events carry `harness.name=harness2`, `harness.collection_method=poll`, the executor's own session id, and the rollout's benchmark/task/label/run/trial/attempt/harness fingerprint under `raw.harness2`. Codex `turn.completed` usage is the thread's running total and is differenced per turn; Codex exec lines carry no times, so they take the file's mtime. No prompts (an argv argument, absent from both streams) and no approvals are recorded or synthesized. `testdata/recorded` holds streams recorded from the exact OpenCode and Codex releases Harness² pins; re-record them when it bumps either. Implementation lives in `cli/beacon/internal/harness2session` and `cli/beacon/cmd/endpoint_harness2.go`.-- Attribution of OTLP events: every account on a machine exports to the same loopback collector, and the exporter's base `user` is the collector process's own account (`asymptoteobserve.NewEvent` reads `$USER`/`$USERNAME`). On Linux the collector replaces it with the account that owns the sending socket (peer attribution): `collector.ConfigYAML` renders, only where `collector.PeerAttribution` (`runtime.GOOS == "linux"`), the `beacon_otlp_http` receiver (`collector-builder/exporter/beaconjsonexporter/otlphttpreceiver`, the upstream OTLP/HTTP protocol rebuilt on confighttp so `client.Info.Addr` keeps the client port that upstream drops; it replaces `otlp.protocols.http` on the same port) and the `beacon_peer` processor (`peerprocessor`, right after `memory_limiter` and before `batch`, which loses the connection) on Beacon's own pipelines, never the OTLP forward's, plus `peer_user: true` on beaconjson. `beacon_peer` removes `beacon.peer.uid`/`beacon.peer.user` wherever a sender put them (resource, scope, record, span, span event and link, every datapoint type), then asks `internal/peercred` for the owner of the client socket of exactly this connection: the client address from `client.Info.Addr` and the collector's end from the gRPC peer's `LocalAddr` or net/http's `LocalAddrContextKey` (no server address, no lookup). `peercred` first asks the kernel with one `NETLINK_SOCK_DIAG` exact four-tuple lookup (`diag_linux.go`, constant cost per export) and scans `/proc/net/tcp{,6}` for the same four-tuple when sock_diag itself is unavailable or, until sock_diag has once answered with a socket, when it says ENOENT (the kernel says that for a missing `tcp_diag` handler too; a socket `/proc` finds then marks sock_diag blind for good); inode 0 (TIME_WAIT/orphan, uid printed 0), no match, or two owners are unknown, never guessed, and an unrelated TIME_WAIT on the same port is skipped. The name comes from `internal/accountname` (shared with `beacon_ingest`). The converter reads the peer attributes from the resource only (`mergeSignalAttrs`), and `applyPeerUser` copies them into `user` only with `Options.PeerUser`, and with it `normalizeClaudeCoworkContext` leaves `user` alone (a sender can call itself Cowork, so its cloud identity stays only in raw attributes; without `PeerUser` it still replaces the collector's account); the `falcon_hec` exporter gets `peer_user: true` too, so LogScale matches the log; with `PeerUser` an unidentified sender gets an empty `user`, never the collector's root, so a recorded root always means root sent it. `CheckComponentsFor` refuses a collector without both where they are rendered. macOS and Windows have no lookup and keep the collector's account (root, or `COMPUTERNAME$` under LocalSystem). Hook and plugin events carry the person's uid or SID from `os/user.Current()` (verified by the OS in restricted mode). The person is also on the session's hook and plugin events, joined by `session.id`; the Sentinel guide carries the KQL. Never describe OTLP events on macOS or Windows as carrying the person who ran the agent.+- Attribution of OTLP events: every account on a machine exports to the same loopback collector, and the exporter's base `user` is the collector process's own account (`asymptoteobserve.NewEvent` reads `$USER`/`$USERNAME`). On Linux the collector replaces it with the account that owns the sending socket (peer attribution): `collector.ConfigYAML` renders, only where `collector.PeerAttribution` (`runtime.GOOS == "linux"`), the `beacon_otlp_http` receiver (`collector-builder/exporter/beaconjsonexporter/otlphttpreceiver`, the upstream OTLP/HTTP protocol rebuilt on confighttp so `client.Info.Addr` keeps the client port that upstream drops; it replaces `otlp.protocols.http` on the same port) and the `beacon_peer` processor (`peerprocessor`, right after `memory_limiter` and before `batch`, which loses the connection) on Beacon's own pipelines, never the OTLP forward's, plus `peer_user: true` on beaconjson. `beacon_peer` removes `beacon.peer.uid`/`beacon.peer.user` wherever a sender put them (resource, scope, record, span, span event and link, every datapoint type), then asks `internal/peercred` for the owner of the client socket of exactly this connection: the client address from `client.Info.Addr` and the collector's end from the gRPC peer's `LocalAddr` or net/http's `LocalAddrContextKey` (no server address, no lookup). `peercred` first asks the kernel with one `NETLINK_SOCK_DIAG` exact four-tuple lookup (`diag_linux.go`, constant cost per export) and scans `/proc/net/tcp{,6}` for the same four-tuple when sock_diag itself is unavailable or, until sock_diag has once answered with a socket, when it says ENOENT (the kernel says that for a missing `tcp_diag` handler too; a socket `/proc` finds then marks sock_diag blind for good); inode 0 (TIME_WAIT/orphan, uid printed 0), no match, or two owners are unknown, never guessed, and an unrelated TIME_WAIT on the same port is skipped. The name comes from `internal/accountname` (shared with `beacon_ingest`). The converter reads the peer attributes from the resource only (`mergeSignalAttrs`), and `applyPeerUser` copies them into `user` only with `Options.PeerUser`, and with it `normalizeClaudeCoworkContext` empties `user` for `claude_cowork` (Cowork reaches a Linux collector only through a relay such as `beacon endpoint cowork --ngrok`, so the kernel names the relay's account, and the cloud identity is the sender's own claim; both stay in raw attributes; without `PeerUser` the cloud identity still replaces the collector's account); the `falcon_hec` exporter gets `peer_user: true` too, so LogScale matches the log; with `PeerUser` an unidentified sender gets an empty `user`, never the collector's root, so a recorded root always means root sent it. `CheckComponentsFor` refuses a collector without both where they are rendered. macOS and Windows have no lookup and keep the collector's account (root, or `COMPUTERNAME$` under LocalSystem). Hook and plugin events carry the person's uid or SID from `os/user.Current()` (verified by the OS in restricted mode). The person is also on the session's hook and plugin events, joined by `session.id`; the Sentinel guide carries the KQL. Never describe OTLP events on macOS or Windows as carrying the person who ran the agent.- Claude Cowork admin-configured OpenTelemetry setup guidance and local validation.- 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.- GitHub Copilot CLI uses MDM/customer-managed OTLP HTTP for live spans and approval-like activity, plus `beacon endpoint copilot sync` to backfill local session records from `~/.copilot/session-state`. Poll events carry assistant text, complete tool results, command/file details, and token usage with `harness.collection_method=poll`, plus the shutdown's session-wide `totalNanoAiu` differenced into `gen_ai.usage.cost_usd` once per shutdown (10^9 nano-AIU = one AI credit = US$0.01), only for sessions started on or after the 2026-06-01 AI-credit cutover (`cli/beacon/internal/copilotsession/cost.go`); approvals still come only from the live OTLP path and are not synthesized from persisted records.diff --git a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.goindex 5a49109f..ed8bbaa7 100644--- a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go+++ b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/converter.go@@ -799,11 +799,15 @@ func NormalizeClaudeToolResult(event *Event, attrs map[string]interface{}) {// normalizeClaudeCoworkContext applies what Claude Cowork reports about itself: where it ran and,// unless peerUser is set, the cloud identity it names in place of the collector's account.//-// With peerUser (beacon_peer in the pipeline) the user field is the kernel's answer for the account-// that sent the export, and nothing a sender writes replaces it. The identity attributes are whatever-// the sender put there, and the harness is only a service name, so letting them win would let any-// local account record an event as uid 0 / root by calling itself Cowork. The cloud identity still-// reaches the log in the event's raw attributes.+// With peerUser (beacon_peer in the pipeline) a Cowork event has no user. Neither answer at hand is+// the person: Cowork runs in the cloud and Claude Desktop does not ship for Linux, so its export+// reaches the collector through a relay (`beacon endpoint cowork --ngrok`, a reverse proxy) and the+// kernel names the relay's local account, the same one for every member of the org; and the cloud+// identity attributes are whatever the sender wrote, behind a harness that is only a service name,+// so honoring them would let any local account record an event as uid 0 / root by calling itself+// Cowork. An empty user is unknown rather than wrong. Both answers stay in the event's raw+// attributes: the cloud identity as Cowork sent it, and the relaying account as beacon.peer.uid and+// beacon.peer.user.func normalizeClaudeCoworkContext(event *Event, attrs map[string]interface{}, peerUser bool) {if event.Harness.Name != "claude_cowork" {return@@ -815,6 +819,7 @@ func normalizeClaudeCoworkContext(event *Event, attrs map[string]interface{}, peevent.Origin = asymptoteobserve.OriginLocal}if peerUser {+ event.User = UserInfo{}return}if name := FirstString(attrs, "user.email", "enduser.id", "user.account_id", "user.account_uuid", "user.id"); name != "" {@@ -2371,7 +2376,8 @@ func EventCategory(action, explicit string) string {// beacon_peer processor resolves the sender from the kernel; this only copies what it found, and// changes nothing when it found nobody, so an unattributed event is the collector's account as it// always was rather than someone's guess. With it on, nothing a sender reports replaces the kernel's-// answer, including Claude Cowork's cloud user (see normalizeClaudeCoworkContext).+// answer; a Claude Cowork event, which arrives through a relay, gets no user instead (see+// normalizeClaudeCoworkContext).func (c Converter) applyPeerUser(event *Event, attrs map[string]interface{}) {if !c.opts.PeerUser {returndiff --git a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/peer_user_test.go b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/peer_user_test.goindex b0b3f01a..6f549fae 100644--- a/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/peer_user_test.go+++ b/collector-builder/exporter/beaconjsonexporter/internal/beaconevent/peer_user_test.go@@ -59,18 +59,18 @@ func TestPeerUserWithoutANameKeepsOnlyTheID(t *testing.T) {}}-// With beacon_peer in the pipeline the kernel's answer is the user, even for a sender that calls-// itself Claude Cowork: the harness is only a service name and the identity attributes are whatever-// the sender wrote, so otherwise any account could record an event as uid 0 / root. The cloud-// identity stays in the raw attributes.-func TestCoworkIdentityDoesNotReplaceThePeer(t *testing.T) {+// With beacon_peer in the pipeline a Claude Cowork event has no user: the kernel names the relay+// that delivered it (the same local account for everyone in the org), and the cloud identity is the+// sender's own claim, which would otherwise let any account record an event as uid 0 / root. Both+// stay in the raw attributes.+func TestCoworkEventHasNoUserUnderThePeer(t *testing.T) {t.Setenv("USER", "root")for _, forged := range []map[string]string{{"user.email": "[email protected]"},{"user.email": "root", "user.account_id": "0"},} {resource, record := peerLog("my-cowork")- resource["cowork.surface"] = "desktop"+ resource["cowork.surface"] = "remote"for k, v := range forged {record.Attributes().PutStr(k, v)}@@ -78,16 +78,19 @@ func TestCoworkIdentityDoesNotReplaceThePeer(t *testing.T) {if event.Harness.Name != "claude_cowork" {t.Fatalf("fixture did not resolve to claude_cowork (%q)", event.Harness.Name)}- if event.User.Name != "alice" || event.User.UID != "1001" {- t.Fatalf("user = %+v with %v, want the kernel's alice/1001", event.User, forged)+ if event.User != (UserInfo{}) {+ t.Fatalf("user = %+v with %v, want none: neither the relay's account nor the claim is the person", event.User, forged)}- if event.Origin != "local" {+ if event.Origin != "cloud" {t.Fatalf("origin = %q, want Cowork's surface still applied", event.Origin)}attrs, _ := event.Raw["attributes"].(map[string]interface{})if attrs["user.email"] != forged["user.email"] {t.Fatalf("raw attributes lost the Cowork identity: %v", attrs)}+ if attrs[PeerUIDAttribute] != "1001" || attrs[PeerUserAttribute] != "alice" {+ t.Fatalf("raw attributes lost the relaying account: %v", attrs)+ }}}diff --git a/docs/changelog/cli.mdx b/docs/changelog/cli.mdxindex a980f6f4..2ad17c65 100644--- a/docs/changelog/cli.mdx+++ b/docs/changelog/cli.mdx@@ -11,7 +11,7 @@ Stay up to date with the latest changes to the Agent Beacon CLI.## Unreleased-- **OpenTelemetry events name the person who sent them on Linux** · On a system install every account exports to the same local collector, so prompts and token usage from Claude Code, Codex and the browser extension were recorded, and forwarded to SIEMs such as Microsoft Sentinel, under the collector's account, `root`, whoever typed them. The Linux collector now records each OpenTelemetry export under the account that owns the connection it arrived on, as the kernel reports it, over gRPC and HTTP alike, and ignores any account a sender names for itself, on the resource or on a record, span or datapoint. That includes an export that calls itself Claude Cowork: on Linux its cloud account stays in the event's raw attributes, and `user` is still the kernel's answer. An export whose sender cannot be identified (it disconnected before the collector looked) carries no `user` at all, rather than the collector's `root`, so a recorded `root` always means root sent it. A Falcon LogScale HEC destination records the same account as `runtime.jsonl`. Beacon's OTLP forward to another backend is unchanged. macOS and Windows are unchanged. Run `beacon endpoint repair --system` (package upgrades do this) to render the new collector config; the collector from the same release is required.+- **OpenTelemetry events name the person who sent them on Linux** · On a system install every account exports to the same local collector, so prompts and token usage from Claude Code, Codex and the browser extension were recorded, and forwarded to SIEMs such as Microsoft Sentinel, under the collector's account, `root`, whoever typed them. The Linux collector now records each OpenTelemetry export under the account that owns the connection it arrived on, as the kernel reports it, over gRPC and HTTP alike, and ignores any account a sender names for itself, on the resource or on a record, span or datapoint. Claude Cowork events on Linux carry no `user`: they reach the collector through a relay such as `beacon endpoint cowork --ngrok`, so the kernel names the relay's account rather than the person, and the cloud account Cowork reports is the sender's own claim. Both stay in the event's raw attributes. An export whose sender cannot be identified (it disconnected before the collector looked) carries no `user` at all, rather than the collector's `root`, so a recorded `root` always means root sent it. A Falcon LogScale HEC destination records the same account as `runtime.jsonl`. Beacon's OTLP forward to another backend is unchanged. macOS and Windows are unchanged. Run `beacon endpoint repair --system` (package upgrades do this) to render the new collector config; the collector from the same release is required.- **Microsoft Sentinel forwarding with one command, on macOS, Linux and Windows** · `beacon endpoint sentinel forwarder install --system` runs the Vector bundled with Beacon as a system service that sends the runtime log to Microsoft Sentinel through the Logs Ingestion API, with a Microsoft Entra app registration (certificate or client secret). The credential is stored where only root can read it, or SYSTEM and Administrators on Windows, and is never a command-line argument. Vector checks the config before anything changes. Repair and package upgrades keep the forwarder and restart it on the new Vector; uninstall removes the service. Throttling, server errors and `401`/`403` answers are retried without a limit, and a line counts as sent only once Azure has accepted it. `status` and `remove` complete the commands. The pack's Logs Ingestion DCR template no longer needs a Data Collection Endpoint. See [Vector and the Logs Ingestion API](/log-forwarding/microsoft-sentinel#vector-and-the-logs-ingestion-api).- **The Windows MSI carries Vector** · The MSI now installs Vector 0.56.0 as `vector.exe` beside `beacon.exe` in `%ProgramFiles%\Beacon\bin`, as the macOS and Linux packages already carry it, checked against the same pinned checksums. Beacon finds it there. The package only installs it; nothing runs it until a forwarder is set up. Allow it alongside the other three programs if you run AppLocker or WDAC.- **Scheduled session sync** · `beacon endpoint install|repair --session-sync` turns on a job that runs every 15 minutes and reads new records from the agent runtimes' local session stores into the runtime log. It runs the same bounded, confined sweep install already runs once, so session-store data keeps reaching the log, and any forwarder reading it, after install. Off by default; repair and upgrades keep the setting, and `--no-session-sync` removes the job. See [Scheduled session sync](/cli/endpoint-install#scheduled-session-sync).diff --git a/docs/log-forwarding/microsoft-sentinel.mdx b/docs/log-forwarding/microsoft-sentinel.mdxindex d6eb4b3a..1a456f29 100644--- a/docs/log-forwarding/microsoft-sentinel.mdx+++ b/docs/log-forwarding/microsoft-sentinel.mdx@@ -232,7 +232,7 @@ One case is not retried. When Microsoft Entra ID refuses the credential itself,### Who ran each session-On a machine several people use, the person behind an event is in `RawData.user`: `uid` is the account's uid, or its SID on Windows, and `name` its name. Hook and plugin events carry it, because each hook and plugin runs as the person who ran the agent; with [restricted log access](/security/restricted-log-access) the operating system vouches for it. On Linux, events from an agent's own OpenTelemetry export, such as Claude Code's token usage and cost or the browser extension's chats, carry the account that sent them too, as the kernel reports it; one whose sender disconnected before the collector could look has no `user`. On macOS and Windows they carry the collector's own account instead (such as `root`, or the machine account `COMPUTERNAME$` on Windows), because every account sends to the same local port and nothing there identifies the sender. On macOS and Windows, Claude Cowork is the exception: its events name the cloud account it reports. On Linux, Cowork events keep the account the kernel reports, and the cloud account is in the event's raw attributes. Both kinds share the session's id, so take the person from the hook and plugin events, and keep an event's own user where its session has none:+On a machine several people use, the person behind an event is in `RawData.user`: `uid` is the account's uid, or its SID on Windows, and `name` its name. Hook and plugin events carry it, because each hook and plugin runs as the person who ran the agent; with [restricted log access](/security/restricted-log-access) the operating system vouches for it. On Linux, events from an agent's own OpenTelemetry export, such as Claude Code's token usage and cost or the browser extension's chats, carry the account that sent them too, as the kernel reports it; one whose sender disconnected before the collector could look has no `user`. On macOS and Windows they carry the collector's own account instead (such as `root`, or the machine account `COMPUTERNAME$` on Windows), because every account sends to the same local port and nothing there identifies the sender. On macOS and Windows, Claude Cowork is the exception: its events name the cloud account it reports. On Linux, Cowork events have no `user`: they arrive through a relay such as `beacon endpoint cowork --ngrok`, so the account the kernel reports is the relay's, not the person's. The cloud account Cowork reports is in `RawData.raw.attributes` (`user.email`, `user.account_uuid`), unverified, beside the relaying account (`beacon.peer.uid`, `beacon.peer.user`). Both kinds share the session's id, so take the person from the hook and plugin events, and keep an event's own user where its session has none:```kql title="Attribute every event to the person who ran its session"let owners = BeaconRuntime_CLdiff --git a/docs/security/restricted-log-access.mdx b/docs/security/restricted-log-access.mdxindex 1a18e4a3..2c062328 100644--- a/docs/security/restricted-log-access.mdx+++ b/docs/security/restricted-log-access.mdx@@ -177,7 +177,7 @@ Restricted mode protects the **log**: what has been recorded cannot be altered o- **A user still controls their own agent.** They can still send events of their own choosing through the socket, including ones that name another session's id, but every event is recorded under their own account, as the operating system reports it. They cannot write an event that claims to be someone else's.- **A user can still change their own agent settings.** The hooks and OpenTelemetry settings that send an agent's activity to Beacon live in each user's home (for example `~/.claude/settings.json`), and that user can edit them, which stops capture of their future sessions. Restricted mode does not change this. Run [`beacon endpoint doctor --system`](/cli/endpoint-doctor#console_user_configured) from your MDM to catch it: `console_user_configured` fails when the logged-in user's agents no longer point at the collector, and `sudo beacon endpoint user-config repair-installed --system` puts the settings back.-- **The OTLP ports are open to every account.** The collector's OTLP receivers on `127.0.0.1:4317` and `4318` still accept telemetry from any local process, as in the shared mode. Agents that export over OTLP, such as Claude Code and Codex, and the browser extension use them. On Linux the collector records each such event under the account that owns the connection it arrived on, as the kernel reports it, and ignores any account the sender names itself; an event whose sender had already disconnected when the collector looked carries no `user` at all, so it is never mistaken for root's. On macOS and Windows these events carry the collector's own account (such as `root`, or the machine account `COMPUTERNAME$` on Windows), not the person who ran the agent: every account on the machine sends to the same port, and nothing there identifies the sender. There, Claude Cowork's events name the cloud account it reports instead, which no one checks either; on Linux they keep the kernel's account and carry the cloud account only in their raw attributes. The person is on the same session's hook and plugin events, which share the OTLP events' `session.id` and which restricted mode does attribute; see [Microsoft Sentinel forwarding](/log-forwarding/microsoft-sentinel#who-ran-each-session) for the join.+- **The OTLP ports are open to every account.** The collector's OTLP receivers on `127.0.0.1:4317` and `4318` still accept telemetry from any local process, as in the shared mode. Agents that export over OTLP, such as Claude Code and Codex, and the browser extension use them. On Linux the collector records each such event under the account that owns the connection it arrived on, as the kernel reports it, and ignores any account the sender names itself; an event whose sender had already disconnected when the collector looked carries no `user` at all, so it is never mistaken for root's. On macOS and Windows these events carry the collector's own account (such as `root`, or the machine account `COMPUTERNAME$` on Windows), not the person who ran the agent: every account on the machine sends to the same port, and nothing there identifies the sender. There, Claude Cowork's events name the cloud account it reports instead, which no one checks either; on Linux they carry no `user`, because they arrive through a relay whose account is not the person's, and keep the cloud account and the relaying account only in their raw attributes. The person is on the same session's hook and plugin events, which share the OTLP events' `session.id` and which restricted mode does attribute; see [Microsoft Sentinel forwarding](/log-forwarding/microsoft-sentinel#who-ran-each-session) for the join.- **Root is trusted.** An administrator can read and change the log in either mode. On Windows that is SYSTEM and any elevated administrator.## Verify