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
add autodetection
Justin D'Souza95ff442849c6
diff --git a/cli/beacon/README.md b/cli/beacon/README.mdindex a10eab3d..a2081f5f 100644--- a/cli/beacon/README.md+++ b/cli/beacon/README.md@@ -29,6 +29,11 @@ Endpoint commands use per-user paths by default so hook and OTLP telemetry share`~/.beacon/endpoint/logs/runtime.jsonl`. Use `--system` for root-manageddeployment paths.+With no `--harness` flag, install and repair discover local runtimes and configure+every integration Beacon can safely install. Pass an exact comma-separated list+to override discovery, or `--harness all` to force every installable integration.+If no installable runtime is detected, Beacon falls back to Claude Code and Codex.+Add optional Splunk HEC forwarding during install or repair:```bashdiff --git a/cli/beacon/cmd/endpoint.go b/cli/beacon/cmd/endpoint.goindex b0ba7d95..8ae63fe7 100644--- a/cli/beacon/cmd/endpoint.go+++ b/cli/beacon/cmd/endpoint.go@@ -415,7 +415,7 @@ func init() {topLevelTracesCmd.Flags().BoolVar(&endpointOpts.systemMode, "system", false, "Use system endpoint paths and the system collector service")topLevelTracesCmd.Flags().StringVar(&endpointOpts.logPath, "log-path", "", "Runtime JSONL log path")- endpointInstallCmd.Flags().StringVar(&endpointOpts.harnesses, "harness", "claude,codex", "Comma-separated harnesses to configure")+ endpointInstallCmd.Flags().StringVar(&endpointOpts.harnesses, "harness", endpointHarnessAuto, "Harnesses to configure: auto (detected runtimes), all, or a comma-separated list")endpointInstallCmd.Flags().IntVar(&endpointOpts.grpcPort, "otlp-grpc-port", endpointconfig.DefaultGRPCPort, "Local OTLP gRPC port")endpointInstallCmd.Flags().IntVar(&endpointOpts.httpPort, "otlp-http-port", endpointconfig.DefaultHTTPPort, "Local OTLP HTTP port")endpointInstallCmd.Flags().StringVar(&endpointOpts.collectorPath, "collector", "", "Path to a beacon-otelcol binary")@@ -436,7 +436,7 @@ func init() {_ = endpointInstallCmd.Flags().MarkDeprecated("content-retention", "Beacon now always captures full content; this flag is ignored")registerSplunkFlags(endpointInstallCmd)registerFalconFlags(endpointInstallCmd)- endpointRepairCmd.Flags().StringVar(&endpointOpts.harnesses, "harness", "claude,codex", "Comma-separated harnesses to configure")+ endpointRepairCmd.Flags().StringVar(&endpointOpts.harnesses, "harness", endpointHarnessAuto, "Harnesses to configure: auto (detected runtimes), all, or a comma-separated list")endpointRepairCmd.Flags().IntVar(&endpointOpts.grpcPort, "otlp-grpc-port", endpointconfig.DefaultGRPCPort, "Local OTLP gRPC port")endpointRepairCmd.Flags().IntVar(&endpointOpts.httpPort, "otlp-http-port", endpointconfig.DefaultHTTPPort, "Local OTLP HTTP port")endpointRepairCmd.Flags().StringVar(&endpointOpts.collectorPath, "collector", "", "Path to a beacon-otelcol binary")diff --git a/cli/beacon/cmd/endpoint_diagnostics.go b/cli/beacon/cmd/endpoint_diagnostics.goindex 87d2650f..0cf23317 100644--- a/cli/beacon/cmd/endpoint_diagnostics.go+++ b/cli/beacon/cmd/endpoint_diagnostics.go@@ -849,12 +849,11 @@ func runEndpointIntegrationsValidate(cmd *cobra.Command, args []string) error {return nil}-func plannedInstallActions(repair bool, kind service.Kind) []plannedAction {+func plannedInstallActions(repair bool, kind service.Kind, otlpTargets, hookTargets []string) []plannedAction {cfg := endpointconfig.Default(endpointUserMode(), endpointOpts.logPath)if endpointOpts.logPath != "" {cfg.LogPath = endpointOpts.logPath}- otlpTargets, hookTargets, _ := splitEndpointTargets(splitHarnessCSV(endpointOpts.harnesses))actions := []plannedAction{}if repair {actions = append(actions, plannedAction{Action: "unload_service", Message: "repair unloads existing endpoint service if present"})diff --git a/cli/beacon/cmd/endpoint_install.go b/cli/beacon/cmd/endpoint_install.goindex dd1568c6..0c76c179 100644--- a/cli/beacon/cmd/endpoint_install.go+++ b/cli/beacon/cmd/endpoint_install.go@@ -92,16 +92,17 @@ func runEndpointDashboard(cmd *cobra.Command, args []string) error {}func runEndpointInstall(cmd *cobra.Command, args []string) error {- otlpHarnesses, hookHarnesses, err := splitEndpointTargets(splitHarnessCSV(endpointOpts.harnesses))+ selection, err := resolveEndpointTargets(endpointOpts.harnesses, harness.DiscoverAll())if err != nil {return err}+ reportEndpointTargetSelection(cmd, selection)serviceKind, err := service.ParseKind(endpointOpts.serviceKind)if err != nil {return err}if endpointOpts.dryRun {- return printPlannedActions(plannedInstallActions(false, serviceKind))+ return printPlannedActions(plannedInstallActions(false, serviceKind, selection.OTLP, selection.Hooks))}// Asked once, on an interactive install, before anything is written to disk. Every// non-interactive path (package postinstall, MDM, CI) is gated out inside.@@ -115,7 +116,7 @@ func runEndpointInstall(cmd *cobra.Command, args []string) error {result, err := lifecycle.Install(lifecycle.InstallOptions{UserMode: endpointUserMode(),LogPath: endpointOpts.logPath,- Harnesses: otlpHarnesses,+ Harnesses: selection.OTLP,GRPCPort: endpointOpts.grpcPort,HTTPPort: endpointOpts.httpPort,CollectorPath: endpointOpts.collectorPath,@@ -149,7 +150,7 @@ func runEndpointInstall(cmd *cobra.Command, args []string) error {fmt.Printf("Scheduled inventory job not installed: %s\n", result.InventoryJobDetail)}printLingerGap(cmd.ErrOrStderr(), result)- installHookTargetsFromEndpointInstall(cmd.ErrOrStderr(), hookHarnesses)+ installHookTargetsFromEndpointInstall(cmd.ErrOrStderr(), selection.Hooks)if connectAfterInstall {// The install is complete and stands on its own; a failed connect is reported// with the retry command rather than turning a working install into an error.@@ -268,16 +269,17 @@ func runEndpointUninstall(cmd *cobra.Command, args []string) error {}func runEndpointRepair(cmd *cobra.Command, args []string) error {- otlpHarnesses, hookHarnesses, err := splitEndpointTargets(splitHarnessCSV(endpointOpts.harnesses))+ selection, err := resolveEndpointTargets(endpointOpts.harnesses, harness.DiscoverAll())if err != nil {return err}+ reportEndpointTargetSelection(cmd, selection)serviceKind, err := service.ParseKind(endpointOpts.serviceKind)if err != nil {return err}if endpointOpts.dryRun {- return printPlannedActions(plannedInstallActions(true, serviceKind))+ return printPlannedActions(plannedInstallActions(true, serviceKind, selection.OTLP, selection.Hooks))}// Resend only. Repair is a maintenance command and never asks a question, but a// signup that failed on a flaky network deserves the retry the docs promise.@@ -285,7 +287,7 @@ func runEndpointRepair(cmd *cobra.Command, args []string) error {result, err := lifecycle.Repair(lifecycle.InstallOptions{UserMode: endpointUserMode(),LogPath: endpointOpts.logPath,- Harnesses: otlpHarnesses,+ Harnesses: selection.OTLP,GRPCPort: endpointOpts.grpcPort,HTTPPort: endpointOpts.httpPort,CollectorPath: endpointOpts.collectorPath,@@ -301,10 +303,33 @@ func runEndpointRepair(cmd *cobra.Command, args []string) error {}fmt.Printf("Endpoint repaired. Manifest: %s\n", result.ManifestPath)printLingerGap(cmd.ErrOrStderr(), result)- installHookTargetsFromEndpointInstall(cmd.ErrOrStderr(), hookHarnesses)+ installHookTargetsFromEndpointInstall(cmd.ErrOrStderr(), selection.Hooks)return nil}+func reportEndpointTargetSelection(cmd *cobra.Command, selection endpointTargetSelection) {+ if !selection.Automatic {+ return+ }+ out := cmd.OutOrStdout()+ if selection.Fallback {+ fmt.Fprintln(out, "No automatically installable runtimes were detected; using the Claude Code and Codex CLI fallback.")+ } else {+ var targets []string+ seen := map[string]bool{}+ for _, target := range append(append([]string(nil), selection.OTLP...), selection.Hooks...) {+ if !seen[target] {+ targets = append(targets, target)+ seen[target] = true+ }+ }+ fmt.Fprintf(out, "Automatically configuring detected runtimes: %s\n", strings.Join(targets, ", "))+ }+ for _, skipped := range selection.Skipped {+ fmt.Fprintf(out, "Detected %s but skipped automatic configuration: %s.\n", skipped.Name, skipped.Reason)+ }+}+// printLingerGap says so when the collector is running but will not outlive this login session.//// Install used to print an unbroken run of success lines here even when the systemd --user unitdiff --git a/cli/beacon/cmd/endpoint_targets.go b/cli/beacon/cmd/endpoint_targets.goindex dccf4e10..dd027ac1 100644--- a/cli/beacon/cmd/endpoint_targets.go+++ b/cli/beacon/cmd/endpoint_targets.go@@ -3,6 +3,8 @@ package cmdimport ("fmt""strings"++ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/harness")type endpointTargetKind string@@ -17,6 +19,61 @@ type endpointTarget struct {Kind endpointTargetKind}+const endpointHarnessAuto = "auto"++type autoEndpointTarget struct {+ OTLP []string+ Hooks []string+ Skip string+}++type skippedEndpointTarget struct {+ Name string+ Reason string+}++type endpointTargetSelection struct {+ OTLP []string+ Hooks []string+ Skipped []skippedEndpointTarget+ Automatic bool+ Fallback bool+}++// autoEndpointTargets maps discovery's canonical event names onto endpoint install's target+// names. Some discovered runtimes deliberately have no install target: Beacon can observe their+// presence, but enabling collection requires an external admin setting, launch environment, or a+// poll command rather than a config file endpoint install may safely mutate.+var autoEndpointTargets = map[string]autoEndpointTarget{+ "claude_code": {OTLP: []string{"claude"}, Hooks: []string{"claude"}},+ "codex_cli": {OTLP: []string{"codex"}, Hooks: []string{"codex"}},+ "gemini_cli": {OTLP: []string{"gemini"}},+ "antigravity_cli": {Hooks: []string{"antigravity"}},+ "copilot_cli": {Skip: "its OTLP endpoint is managed through the Copilot CLI launch environment"},+ "opencode": {Hooks: []string{"opencode"}},+ "cline": {Hooks: []string{"cline"}},+ "pi_cli": {Hooks: []string{"pi"}},+ "omp": {Hooks: []string{"omp"}},+ "openclaw": {Hooks: []string{"openclaw"}},+ "grok": {Hooks: []string{"grok"}},+ "prime_agent": {Hooks: []string{"prime"}},+ "omo_senpi": {Hooks: []string{"omo"}},+ "vercel_fx": {Skip: "collection is enabled by running `beacon endpoint fx sync`"},+ "deepseek_harness": {Hooks: []string{"dsh"}},+ "qwen_code": {Hooks: []string{"qwen"}},+ "kimi_code": {Hooks: []string{"kimi"}},+ "kiro": {Hooks: []string{"kiro"}},+ "muse_code": {Hooks: []string{"muse"}},+ "openhands": {Skip: "the CLI and GUI require project-level hooks installed from inside each repository"},+ "hermes": {Hooks: []string{"hermes"}},+ "factory": {Hooks: []string{"factory"}},+ "vscode": {OTLP: []string{"vscode"}, Hooks: []string{"vscode"}},+ "cursor": {Hooks: []string{"cursor"}},+ "devin-cli": {Hooks: []string{"devin-cli"}},+ "devin-desktop": {Hooks: []string{"devin-desktop"}},+ "claude_cowork": {Skip: "its OTLP endpoint requires Claude admin configuration"},+}+// harnessTarget is one row of the supported-harness registry. It is the single// source of truth for both normalizers://@@ -250,6 +307,84 @@ func splitEndpointTargets(values []string) (otlp []string, hooks []string, err ereturn otlp, hooks, nil}+func resolveEndpointTargets(value string, discovered []harness.Harness) (endpointTargetSelection, error) {+ values := splitHarnessCSV(value)+ if len(values) != 1 || (normalizeHarnessKey(values[0]) != endpointHarnessAuto && normalizeHarnessKey(values[0]) != "all") {+ otlp, hooks, err := splitEndpointTargets(values)+ return endpointTargetSelection{OTLP: otlp, Hooks: hooks}, err+ }++ switch normalizeHarnessKey(values[0]) {+ case "all":+ return allInstallableEndpointTargets(), nil+ case endpointHarnessAuto:+ selection := endpointTargetSelection{Automatic: true}+ seenOTLP := map[string]bool{}+ seenHooks := map[string]bool{}+ for _, found := range discovered {+ if !found.Detected {+ continue+ }+ target, ok := autoEndpointTargets[found.Name]+ if !ok {+ selection.Skipped = append(selection.Skipped, skippedEndpointTarget{+ Name: found.DisplayName,+ Reason: "no automatic installer is registered",+ })+ continue+ }+ if target.Skip != "" {+ selection.Skipped = append(selection.Skipped, skippedEndpointTarget{+ Name: found.DisplayName,+ Reason: target.Skip,+ })+ continue+ }+ for _, name := range target.OTLP {+ if !seenOTLP[name] {+ selection.OTLP = append(selection.OTLP, name)+ seenOTLP[name] = true+ }+ }+ for _, name := range target.Hooks {+ if !seenHooks[name] {+ selection.Hooks = append(selection.Hooks, name)+ seenHooks[name] = true+ }+ }+ }+ if len(selection.OTLP) == 0 && len(selection.Hooks) == 0 {+ // Preserve the historical unattended-install behavior when discovery has no useful+ // user environment (for example a package postinstall running as root).+ selection.OTLP = []string{"claude", "codex"}+ selection.Hooks = []string{"claude", "codex"}+ selection.Fallback = true+ }+ return selection, nil+ default:+ panic("unreachable endpoint harness selection")+ }+}++func allInstallableEndpointTargets() endpointTargetSelection {+ selection := endpointTargetSelection{}+ seenOTLP := map[string]bool{}+ seenHooks := map[string]bool{}+ for _, target := range harnessTargets {+ if target.endpointKind == endpointTargetOTLP && !seenOTLP[target.name] {+ selection.OTLP = append(selection.OTLP, target.name)+ seenOTLP[target.name] = true+ }+ // hookAliases is also populated on OTLP rows whose runtime has a separately+ // installable hook integration, notably Claude, Codex, and VS Code.+ if len(target.hookAliases) > 0 && !seenHooks[target.name] {+ selection.Hooks = append(selection.Hooks, target.name)+ seenHooks[target.name] = true+ }+ }+ return selection+}+func canonicalHookTargets(values []string) ([]string, error) {seen := map[string]bool{}targets := []string{}diff --git a/cli/beacon/cmd/endpoint_test.go b/cli/beacon/cmd/endpoint_test.goindex e0f6426b..c5303ad1 100644--- a/cli/beacon/cmd/endpoint_test.go+++ b/cli/beacon/cmd/endpoint_test.go@@ -17,6 +17,7 @@ import (endpointconfig "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/config""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/dashboard""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/diagnostics"+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/harness"endpointinventory "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/inventory""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/lifecycle""github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/selfupdate"@@ -68,18 +69,21 @@ func TestSplitEndpointTargetsDedupesHookAliases(t *testing.T) {// start, end, file activity, or subagent lifecycle, since Claude's OTLP export has none.func TestDefaultInstallHarnessesCarryClaudeAndCodexHooks(t *testing.T) {defaultList := endpointInstallCmd.Flags().Lookup("harness").DefValue- otlp, hooks, err := splitEndpointTargets(splitHarnessCSV(defaultList))+ selection, err := resolveEndpointTargets(defaultList, []harness.Harness{+ {Name: "claude_code", DisplayName: "Claude Code", Detected: true},+ {Name: "codex_cli", DisplayName: "Codex CLI", Detected: true},+ })if err != nil {- t.Fatalf("splitEndpointTargets(%q) returned error: %v", defaultList, err)+ t.Fatalf("resolveEndpointTargets(%q) returned error: %v", defaultList, err)}- if got, want := strings.Join(otlp, ","), "claude,codex"; got != want {+ if got, want := strings.Join(selection.OTLP, ","), "claude,codex"; got != want {t.Fatalf("default otlp targets = %q, want %q", got, want)}- if got, want := strings.Join(hooks, ","), "claude,codex"; got != want {+ if got, want := strings.Join(selection.Hooks, ","), "claude,codex"; got != want {t.Fatalf("default hook targets = %q, want %q", got, want)}// Listing the explicit hook alias as well must not install Claude hooks twice.- _, hooks, err = splitEndpointTargets([]string{"claude", "claude-hooks", "codex"})+ _, hooks, err := splitEndpointTargets([]string{"claude", "claude-hooks", "codex"})if err != nil {t.Fatal(err)}@@ -88,6 +92,88 @@ func TestDefaultInstallHarnessesCarryClaudeAndCodexHooks(t *testing.T) {}}+func TestResolveEndpointTargetsAutoInstallsEveryDetectedInstallableRuntime(t *testing.T) {+ selection, err := resolveEndpointTargets("auto", []harness.Harness{+ {Name: "claude_code", DisplayName: "Claude Code", Detected: true},+ {Name: "vscode", DisplayName: "VS Code", Detected: true},+ {Name: "opencode", DisplayName: "opencode", Detected: true},+ {Name: "vercel_fx", DisplayName: "fx", Detected: true},+ {Name: "cursor", DisplayName: "Cursor", Detected: false},+ })+ if err != nil {+ t.Fatal(err)+ }+ if got, want := strings.Join(selection.OTLP, ","), "claude,vscode"; got != want {+ t.Fatalf("auto OTLP targets = %q, want %q", got, want)+ }+ if got, want := strings.Join(selection.Hooks, ","), "claude,vscode,opencode"; got != want {+ t.Fatalf("auto hook targets = %q, want %q", got, want)+ }+ if len(selection.Skipped) != 1 || selection.Skipped[0].Name != "fx" {+ t.Fatalf("auto skipped targets = %#v, want fx", selection.Skipped)+ }+ if selection.Fallback {+ t.Fatal("auto selection unexpectedly used fallback")+ }+}++func TestResolveEndpointTargetsAutoFallsBackWhenNothingInstallableDetected(t *testing.T) {+ selection, err := resolveEndpointTargets("auto", []harness.Harness{+ {Name: "vercel_fx", DisplayName: "fx", Detected: true},+ })+ if err != nil {+ t.Fatal(err)+ }+ if got, want := strings.Join(selection.OTLP, ","), "claude,codex"; got != want {+ t.Fatalf("fallback OTLP targets = %q, want %q", got, want)+ }+ if got, want := strings.Join(selection.Hooks, ","), "claude,codex"; got != want {+ t.Fatalf("fallback hook targets = %q, want %q", got, want)+ }+ if !selection.Fallback {+ t.Fatal("auto selection did not mark fallback")+ }+}++func TestResolveEndpointTargetsExplicitListDoesNotAutoDetect(t *testing.T) {+ selection, err := resolveEndpointTargets("gemini,cursor", []harness.Harness{+ {Name: "opencode", DisplayName: "opencode", Detected: true},+ })+ if err != nil {+ t.Fatal(err)+ }+ if got, want := strings.Join(selection.OTLP, ","), "gemini"; got != want {+ t.Fatalf("explicit OTLP targets = %q, want %q", got, want)+ }+ if got, want := strings.Join(selection.Hooks, ","), "cursor"; got != want {+ t.Fatalf("explicit hook targets = %q, want %q", got, want)+ }+ if selection.Automatic {+ t.Fatal("explicit selection marked automatic")+ }+}++func TestResolveEndpointTargetsAllIncludesOTLPAndHookVariants(t *testing.T) {+ selection, err := resolveEndpointTargets("all", nil)+ if err != nil {+ t.Fatal(err)+ }+ if got := strings.Join(selection.OTLP, ","); !strings.Contains(got, "claude") || !strings.Contains(got, "vscode") {+ t.Fatalf("all OTLP targets = %q, want Claude and VS Code", got)+ }+ if got := strings.Join(selection.Hooks, ","); !strings.Contains(got, "openhands") || !strings.Contains(got, "muse") || !strings.Contains(got, "vscode") {+ t.Fatalf("all hook targets = %q, want OpenHands, Muse, and VS Code", got)+ }+}++func TestAutoEndpointTargetsCoversDiscoveryRegistry(t *testing.T) {+ for _, discovered := range harness.DiscoverAll() {+ if _, ok := autoEndpointTargets[discovered.Name]; !ok {+ t.Errorf("discovery target %q (%s) has no automatic install or skip rule", discovered.Name, discovered.DisplayName)+ }+ }+}+func TestCanonicalHookTargetsNormalizesAliasesToSwitchNames(t *testing.T) {got, err := canonicalHookTargets([]string{"claude_code", "codex_cli", "vs_code", "droid", "devin", "devin_desktop", "antigravity_cli", "hermes-agent"})if err != nil {@@ -107,7 +193,11 @@ func TestPlannedInstallActionsSeparatesHookHarnesses(t *testing.T) {endpointOpts.logPath = filepath.Join(t.TempDir(), "runtime.jsonl")endpointOpts.noStart = true- actions := plannedInstallActions(false, service.KindAuto)+ otlp, hooks, err := splitEndpointTargets(splitHarnessCSV(endpointOpts.harnesses))+ if err != nil {+ t.Fatal(err)+ }+ actions := plannedInstallActions(false, service.KindAuto, otlp, hooks)counts := map[string]int{}hookRows := map[string]int{}for _, action := range actions {@@ -853,12 +943,12 @@ func TestBasicAuthHeader(t *testing.T) {}}-func TestEndpointHarnessDefaultsDoNotClobberInstall(t *testing.T) {+func TestEndpointHarnessDefaults(t *testing.T) {installFlag := endpointInstallCmd.Flags().Lookup("harness")if installFlag == nil {t.Fatal("install command missing --harness flag")}- if got, want := installFlag.DefValue, "claude,codex"; got != want {+ if got, want := installFlag.DefValue, "auto"; got != want {t.Fatalf("install --harness default = %q, want %q", got, want)}diff --git a/cli/beacon/internal/endpoint/harness/harness.go b/cli/beacon/internal/endpoint/harness/harness.goindex 9a6845c1..37729b1c 100644--- a/cli/beacon/internal/endpoint/harness/harness.go+++ b/cli/beacon/internal/endpoint/harness/harness.go@@ -67,6 +67,9 @@ func DiscoverAll() []Harness {DiscoverDsh(),DiscoverQwen(),DiscoverKimi(),+ DiscoverKiro(),+ DiscoverMuse(),+ DiscoverOpenHands(),DiscoverHermes(),DiscoverFactory(),DiscoverVSCode(),diff --git a/cli/beacon/internal/endpoint/harness/hook_only.go b/cli/beacon/internal/endpoint/harness/hook_only.gonew file mode 100644index 00000000..07dc527a--- /dev/null+++ b/cli/beacon/internal/endpoint/harness/hook_only.go@@ -0,0 +1,77 @@+package harness++import (+ "path/filepath"++ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/hooks"+)++// DiscoverKiro reports the user-level Kiro hook state. A project hook is not used as the+// machine-wide status because Kiro merges both scopes and the default endpoint install writes the+// user-level file that covers the local IDE and CLI across repositories.+func DiscoverKiro() Harness {+ h := Harness{Name: "kiro", DisplayName: "Kiro", Capability: "hooks"}+ detectExecutable(&h, "kiro-cli")+ status := hooks.KiroHookStatus(hooks.KiroOptions{Level: hooks.LevelUser})+ h.ConfigPath = status.HooksPath+ if !h.Detected && status.HooksPath != "" && dirExists(filepath.Dir(filepath.Dir(status.HooksPath))) {+ h.Detected = true+ }+ if status.Installed {+ h.TelemetryStatus = TelemetryEnabled+ h.Message = status.Message+ } else {+ h.TelemetryStatus = TelemetryMissing+ h.Message = status.Message+ }+ return h+}++// DiscoverMuse reports whether Muse Code is present and whether both halves of Beacon's managed+// hook registration are installed. Muse has no working project-level hook registration.+func DiscoverMuse() Harness {+ h := Harness{Name: "muse_code", DisplayName: "Muse Code", Capability: "hooks"}+ detectExecutable(&h, "muse")+ status := hooks.MuseHookStatus(hooks.MuseOptions{Level: hooks.LevelUser})+ h.ConfigPath = status.SettingsPath+ if !h.Detected && status.SettingsPath != "" && dirExists(filepath.Dir(status.SettingsPath)) {+ h.Detected = true+ }+ if status.Installed {+ h.TelemetryStatus = TelemetryEnabled+ h.Message = status.Message+ } else {+ h.TelemetryStatus = TelemetryMissing+ h.Message = status.Message+ }+ return h+}++// DiscoverOpenHands checks both scopes because OpenHands resolves rather than merges them: the+// repository file used by the CLI and GUI shadows the user-level SDK file.+func DiscoverOpenHands() Harness {+ h := Harness{Name: "openhands", DisplayName: "OpenHands", Capability: "hooks"}+ detectExecutable(&h, "openhands")+ user := hooks.OpenHandsHookStatus(hooks.OpenHandsOptions{Level: hooks.LevelUser})+ project := hooks.OpenHandsHookStatus(hooks.OpenHandsOptions{Level: hooks.LevelProject})+ h.ConfigPath = user.HooksPath+ if project.Installed {+ h.ConfigPath = project.HooksPath+ }+ if !h.Detected {+ h.Detected = (user.HooksPath != "" && dirExists(filepath.Dir(user.HooksPath))) ||+ (project.HooksPath != "" && dirExists(filepath.Dir(project.HooksPath)))+ }+ switch {+ case project.Installed:+ h.TelemetryStatus = TelemetryEnabled+ h.Message = "OpenHands project hooks are installed"+ case user.Installed:+ h.TelemetryStatus = TelemetryEnabled+ h.Message = "OpenHands user hooks are installed for SDK sessions; project hooks are required for the CLI and GUI"+ default:+ h.TelemetryStatus = TelemetryMissing+ h.Message = "OpenHands project hooks are not installed"+ }+ return h+}diff --git a/cli/beacon/internal/endpoint/harness/hook_only_test.go b/cli/beacon/internal/endpoint/harness/hook_only_test.gonew file mode 100644index 00000000..9bf0b36c--- /dev/null+++ b/cli/beacon/internal/endpoint/harness/hook_only_test.go@@ -0,0 +1,53 @@+package harness++import (+ "os"+ "path/filepath"+ "testing"++ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/testenv"+)++func setupHookOnlyDiscovery(t *testing.T) string {+ t.Helper()+ home := t.TempDir()+ testenv.SetHome(t, home)+ t.Setenv("PATH", t.TempDir())+ t.Setenv("KIRO_HOME", "")+ t.Setenv("XDG_CONFIG_HOME", "")+ t.Setenv("OH_PERSISTENCE_DIR", "")+ return home+}++func TestDiscoverKiroDetectsProfileDirectory(t *testing.T) {+ home := setupHookOnlyDiscovery(t)+ if err := os.MkdirAll(filepath.Join(home, ".kiro"), 0755); err != nil {+ t.Fatal(err)+ }+ h := DiscoverKiro()+ if !h.Detected || h.Name != "kiro" || h.TelemetryStatus != TelemetryMissing {+ t.Fatalf("DiscoverKiro() = %#v", h)+ }+}++func TestDiscoverMuseDetectsConfigDirectory(t *testing.T) {+ home := setupHookOnlyDiscovery(t)+ if err := os.MkdirAll(filepath.Join(home, ".config", "muse"), 0755); err != nil {+ t.Fatal(err)+ }+ h := DiscoverMuse()+ if !h.Detected || h.Name != "muse_code" || h.TelemetryStatus != TelemetryMissing {+ t.Fatalf("DiscoverMuse() = %#v", h)+ }+}++func TestDiscoverOpenHandsDetectsPersistenceDirectory(t *testing.T) {+ home := setupHookOnlyDiscovery(t)+ if err := os.MkdirAll(filepath.Join(home, ".openhands"), 0755); err != nil {+ t.Fatal(err)+ }+ h := DiscoverOpenHands()+ if !h.Detected || h.Name != "openhands" || h.TelemetryStatus != TelemetryMissing {+ t.Fatalf("DiscoverOpenHands() = %#v", h)+ }+}diff --git a/docs/cli/endpoint-install.mdx b/docs/cli/endpoint-install.mdxindex 9b1bfb95..330d0933 100644--- a/docs/cli/endpoint-install.mdx+++ b/docs/cli/endpoint-install.mdx@@ -13,7 +13,11 @@ The service is a launchd job on macOS and a systemd unit on Linux. Where neitherbeacon endpoint install```-By default, Beacon configures Claude Code and Codex CLI telemetry for local or customer-controlled runtime JSONL logs. Gemini CLI and VS Code Copilot telemetry are opt-in with the `gemini` and `vscode` harnesses. The `claude` harness writes both Claude Code's OpenTelemetry settings and its user-level hooks, because the OTLP export alone carries no session start or end, file activity, or subagent lifecycle; `beacon endpoint hooks uninstall --harness claude` removes the hooks again, and `beacon endpoint hooks install --harness claude --level project` adds project-level ones. A hook that cannot be written, for example into a settings file whose `hooks` key is not an object, is reported as a warning with the retry command; the endpoint itself is installed and `endpoint install` still exits 0. Codex uses OTLP logs plus one selective turn trace for tokens, and its required SessionStart hook adds local OS-user context. Beacon applies redaction, sanitization, truncation, and event-size limits before writing supported content fields. GitHub Copilot CLI and Factory Droid OTLP are managed through their launch environments, so Beacon validates their telemetry state but does not mutate shell profiles during install.+By default, Beacon discovers the runtimes installed for the invoking user and configures every integration it can safely install. This includes OTLP settings and supported hooks, plugins, or extensions; VS Code receives both its OTLP and hook configuration. An explicit `--harness` list disables automatic selection. If discovery finds no automatically installable runtime, Beacon preserves the unattended-install fallback by configuring Claude Code and Codex CLI.++Discovery can also find runtimes whose collection path cannot be enabled safely by a machine-wide default. Beacon reports these without treating them as install failures: GitHub Copilot CLI needs launch-environment settings, Claude Cowork needs admin configuration, poll-only fx needs `beacon endpoint fx sync`, and OpenHands CLI/GUI coverage requires project-level hooks installed from inside each repository. Factory Droid's hooks are installed automatically when Droid is detected, while its separate OTLP endpoint remains launch-environment managed.++The `claude` harness writes both Claude Code's OpenTelemetry settings and its user-level hooks, because the OTLP export alone carries no session start or end, file activity, or subagent lifecycle; `beacon endpoint hooks uninstall --harness claude` removes the hooks again, and `beacon endpoint hooks install --harness claude --level project` adds project-level ones. A hook that cannot be written, for example into a settings file whose `hooks` key is not an object, is reported as a warning with the retry command; the endpoint itself is installed and `endpoint install` still exits 0. Codex uses OTLP logs plus one selective turn trace for tokens, and its required SessionStart hook adds local OS-user context. Beacon applies redaction, sanitization, truncation, and event-size limits before writing supported content fields.## Flags@@ -22,7 +26,7 @@ By default, Beacon configures Claude Code and Codex CLI telemetry for local or c| `--user` | Use per-user endpoint paths. Enabled by default || `--system` | Use system endpoint paths and launch daemon. Requires root || `--log-path <path>` | Runtime JSONL log path |-| `--harness <list>` | Comma-separated harnesses to configure. Defaults to `claude,codex`, each of which installs its OTLP settings and its hooks; include `gemini` for Gemini CLI or `vscode` for VS Code Copilot OTLP telemetry. Hook harnesses can be listed alongside them: `cursor`, `factory`, `opencode`, `cline`, `pi`, `omp`, `openclaw`, `grok`, `qwen`, `hermes`, `antigravity`, `devin-cli`, `devin-desktop`, `dsh`, and `kimi`, for example `beacon endpoint install --harness claude,codex,cursor,kimi`. DeepSeek Harness and Kimi Code are user-level only. `beacon endpoint hooks install` adds the same hooks to an existing install later, and is the only way to add VS Code hook telemetry. GitHub Copilot CLI and Factory Droid OTLP endpoints are managed through their launch environments |+| `--harness <selection>` | Harnesses to configure. Defaults to `auto`, which installs every detected integration Beacon can configure and reports detected manual or poll-only integrations. Use `all` to force every installable integration, or pass an exact comma-separated list such as `claude,codex,cursor,kimi`. DeepSeek Harness and Kimi Code are user-level only. An explicit list preserves exact-selection behavior || `--otlp-grpc-port <port>` | Local OTLP gRPC port. Defaults to `4317` || `--otlp-http-port <port>` | Local OTLP HTTP port. Defaults to `4318` || `--collector <path>` | Path to a `beacon-otelcol` binary |@@ -88,12 +92,18 @@ Configure only one harness:beacon endpoint install --harness claude```-Opt in Gemini CLI telemetry alongside the defaults:+Override discovery with an exact harness list:-```bash title="Opt in Gemini CLI telemetry alongside the defaults"+```bash title="Configure an exact harness list"beacon endpoint install --harness claude,codex,gemini```+Force every installable integration without checking whether its runtime is present:++```bash title="Configure all supported integrations"+beacon endpoint install --harness all+```+Configure VS Code Copilot telemetry:```bash title="Configure VS Code Copilot telemetry"diff --git a/docs/cli/endpoint-repair.mdx b/docs/cli/endpoint-repair.mdxindex a76a07b8..aded2a6a 100644--- a/docs/cli/endpoint-repair.mdx+++ b/docs/cli/endpoint-repair.mdx@@ -11,7 +11,7 @@ description: "Repair Beacon endpoint service files, collector configuration, andbeacon endpoint repair```-Repair preserves runtime logs and harness telemetry configuration while reinstalling managed endpoint files. GitHub Copilot CLI and Factory Droid launch-environment settings remain customer-managed; repair validates their telemetry state but does not write those environment settings.+Repair preserves runtime logs while reinstalling managed endpoint files. By default it rediscovers installed runtimes and reapplies every integration Beacon can configure. Pass an explicit `--harness` list to repair only those targets. GitHub Copilot CLI and Factory Droid launch-environment settings remain customer-managed; repair does not write those environment settings.During repair, Beacon removes the existing managed service before reinstalling it so an unhealthy collector can release local OTLP ports. If reinstall cannot complete, Beacon restores the previous endpoint configuration so local state is not left partially rolled back.@@ -22,7 +22,7 @@ During repair, Beacon removes the existing managed service before reinstalling i| `--user` | Use per-user endpoint paths. Enabled by default || `--system` | Use system endpoint paths and launch daemon || `--log-path <path>` | Runtime JSONL log path |-| `--harness <list>` | Comma-separated harnesses to configure. Defaults to `claude,codex`; include `gemini` for Gemini CLI or `vscode` for VS Code Copilot OTLP telemetry. Hook harnesses can be listed alongside them: `claude-hooks` (Claude Code hooks), `cursor`, `factory`, `opencode`, `cline`, `pi`, `omp`, `openclaw`, `grok`, `qwen`, `hermes`, `antigravity`, `devin-cli`, `devin-desktop`, `dsh`, and `kimi`, for example `beacon endpoint repair --harness claude,codex,cursor,kimi`. DeepSeek Harness and Kimi Code are user-level only. `beacon endpoint hooks install` adds the same hooks to an existing install later, and is the only way to add VS Code hook telemetry. GitHub Copilot CLI and Factory Droid OTLP endpoints are managed through their launch environments |+| `--harness <selection>` | Harnesses to configure. Defaults to `auto`, which repairs every detected integration Beacon can configure. Use `all` to force every installable integration, or pass an exact comma-separated list such as `claude,codex,cursor,kimi`. DeepSeek Harness and Kimi Code are user-level only || `--otlp-grpc-port <port>` | Local OTLP gRPC port. Defaults to `4317` || `--otlp-http-port <port>` | Local OTLP HTTP port. Defaults to `4318` || `--collector <path>` | Path to a `beacon-otelcol` binary |diff --git a/docs/deployment/open-source.mdx b/docs/deployment/open-source.mdxindex 4c82de70..793c714f 100644--- a/docs/deployment/open-source.mdx+++ b/docs/deployment/open-source.mdx@@ -80,9 +80,9 @@ beacon endpoint installbeacon endpoint status```-By default, Beacon configures Claude Code and Codex CLI to export telemetry to a local OpenTelemetry Collector on `127.0.0.1`. Add Gemini when you want Beacon to manage Gemini OTLP settings too:+By default, Beacon detects runtimes installed for the invoking user and configures every integration it can safely install. Pass an exact list when you want deterministic target selection:-```bash title="Include Gemini telemetry"+```bash title="Configure an exact runtime set"beacon endpoint install --harness claude,codex,gemini```diff --git a/docs/runtimes/gemini-cli.mdx b/docs/runtimes/gemini-cli.mdxindex f0cc44eb..3acba442 100644--- a/docs/runtimes/gemini-cli.mdx+++ b/docs/runtimes/gemini-cli.mdx@@ -5,7 +5,7 @@ description: "Beacon support details for Gemini CLI endpoint telemetry"## Runtime overview-Beacon supports Gemini CLI through opt-in local OTLP logs, traces, and metrics.+Beacon supports Gemini CLI through local OTLP logs, traces, and metrics. The default endpoint install enables it when Gemini is detected.## Prerequisites@@ -13,7 +13,7 @@ Before enabling Gemini CLI telemetry, make sure:- Gemini CLI is installed and available as the `gemini` executable for the user or managed endpoint.- `beacon endpoint install` has run so the local collector, endpoint config, and runtime log path exist.-- The install explicitly includes Gemini, for example `beacon endpoint install --harness claude,codex,gemini`.+- Gemini is detectable through its executable or user configuration. If automatic discovery is unavailable in an unattended environment, explicitly include it with `beacon endpoint install --harness claude,codex,gemini`.- No project settings or `GEMINI_TELEMETRY_*` environment variables override the user-level Beacon settings you expect to use.- Your team has reviewed content handling and destination access for prompt telemetry.@@ -27,7 +27,7 @@ Beacon detects Gemini CLI through the `gemini` executable and `~/.gemini/setting## Install or configuration support-Gemini CLI telemetry is opt-in. Run `beacon endpoint install --harness claude,codex,gemini` when you want Beacon to manage Gemini telemetry settings.+The default `beacon endpoint install` configures Gemini automatically when it is detected. Run `beacon endpoint install --harness claude,codex,gemini` to select it explicitly instead.Beacon writes local OTLP settings to `~/.gemini/settings.json`, sets `target` to `local`, uses OTLP gRPC, enables collector mode, and removes `outfile` so telemetry flows to Beacon.diff --git a/docs/runtimes/index.mdx b/docs/runtimes/index.mdxindex c54fb7c9..81b45323 100644--- a/docs/runtimes/index.mdx+++ b/docs/runtimes/index.mdx@@ -113,12 +113,12 @@ MDM assets, meaning Jamf Pro Extension Attributes, Fleet osquery queries, and Ri| Runtime | Enterprise configuration ||---------|--------------------------|-| Claude Code | `beacon endpoint install` configures local OTLP export. Install hooks with `beacon endpoint hooks install --harness claude` when you need richer live telemetry. To backfill committed transcripts, schedule `beacon endpoint claude sync` in the logged-in user's context or leave `--watch` running. |-| Cursor | Install hooks with `beacon endpoint hooks install --harness cursor`. To backfill committed local sessions, schedule `beacon endpoint cursor sync` in the logged-in user's context or leave `--watch` running. |+| Claude Code | The default `beacon endpoint install` detects Claude and configures local OTLP export plus hooks. To backfill committed transcripts, schedule `beacon endpoint claude sync` in the logged-in user's context or leave `--watch` running. |+| Cursor | The default `beacon endpoint install` detects Cursor and installs its hooks. To backfill committed local sessions, schedule `beacon endpoint cursor sync` in the logged-in user's context or leave `--watch` running. || Cline | Install the managed plugin with `beacon endpoint hooks install --harness cline`. To backfill committed local tasks and sessions, schedule `beacon endpoint cline sync` in the logged-in user's context or leave `--watch` running. || Codex CLI | `beacon endpoint install` configures local OTLP export. To backfill committed sessions, schedule `beacon endpoint codex sync` in the logged-in user's context or leave `--watch` running. || DeepSeek Harness | Install hooks with `beacon endpoint hooks install --harness dsh`. To backfill committed native sessions, schedule `beacon endpoint dsh sync` in the logged-in user's context or leave `--watch` running. |-| Gemini CLI | Opt in by adding `gemini` to the endpoint harness list, for example `claude,codex,gemini`. Beacon can then manage `~/.gemini/settings.json` for local OTLP collection. |+| Gemini CLI | The default `beacon endpoint install` detects Gemini and manages `~/.gemini/settings.json` for local OTLP collection. Use an explicit list such as `claude,codex,gemini` when automatic discovery is unavailable. || 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. || OpenCode | Install the managed plugin for live telemetry with `beacon endpoint hooks install --harness opencode`. To backfill committed local sessions, schedule [`beacon endpoint opencode sync`](/cli/endpoint-opencode) in the logged-in user's context or leave `--watch` running. || Pi | Install the managed extension for live telemetry with `beacon endpoint hooks install --harness pi`. To backfill committed local sessions, schedule [`beacon endpoint pi sync`](/cli/endpoint-pi) in the logged-in user's context or leave `--watch` running. |@@ -130,7 +130,7 @@ MDM assets, meaning Jamf Pro Extension Attributes, Fleet osquery queries, and Ri| OpenClaw Gateway | Install the managed plugin in the account the gateway runs as with `beacon endpoint hooks install --harness openclaw`, then grant `plugins.entries.beacon-endpoint.hooks.allowConversationAccess` in OpenClaw's own config so token usage is collected. For the gateway's OTLP export, use [`beacon endpoint integrations openclaw`](/cli/openclaw) to print local settings and validate events; Beacon never writes OpenClaw's config. To backfill committed session files, schedule `beacon endpoint integrations openclaw sessions sync` in the gateway account or leave `--watch` running. || Prime Agent | Install the managed extension for live telemetry with `beacon endpoint hooks install --harness prime`. To backfill committed local sessions and subagent artifacts, schedule `beacon endpoint prime sync` in the logged-in user's context or leave `--watch` running. |-Install hooks separately in the logged-in user's context when you need richer hook telemetry. This applies to Antigravity CLI, Claude Code, Cline, Codex CLI session-context hooks, Cursor, Devin CLI, Devin Desktop, Factory Droid, Grok Build, Hermes Agent, Kimi Code, Muse Code, Oh My Pi, OpenClaw Gateway, OpenCode, OpenHands, Pi, Qwen Code, and the optional VS Code hooks. goose is the current exception: its adapter can map manually configured hooks, but Beacon does not yet install or discover it. Poll sync commands are also run or scheduled in the account that owns the runtime's local session store.+The default user-mode install discovers and configures supported user-level hooks, plugins, and extensions. Use `beacon endpoint hooks install` for an explicit target or project-level setup. OpenHands CLI/GUI coverage specifically requires project scope, and goose remains the exception: its adapter can map manually configured hooks, but Beacon does not yet install or discover it. System packages and MDM scripts keep their explicit fleet harness lists because runtime hook configuration belongs to the logged-in user's profile. Poll sync commands are also run or scheduled in the account that owns the runtime's local session store.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 a770c429..164fc5e8 100644--- a/docs/runtimes/integration-model.mdx+++ b/docs/runtimes/integration-model.mdx@@ -46,13 +46,13 @@ During install, Beacon configures the runtime surfaces it can safely manage:|--------------------|-----------------------|| [Claude Code](/runtimes/claude-code) | Beacon points Claude Code at the local OTLP collector. Hook installation is separate through [`beacon endpoint hooks`](/cli/hooks). Historical transcripts can be backfilled with `beacon endpoint claude sync`. || [Codex CLI](/runtimes/codex-cli) | Beacon points Codex CLI at the local OTLP collector, writes log and trace exporter tables to `~/.codex/config.toml`, enables prompt logging, retains one usage-bearing turn span, and installs a metadata-only SessionStart identity hook. Historical sessions can be backfilled with `beacon endpoint codex sync`. |-| [Gemini CLI](/runtimes/gemini-cli) | Optional with `--harness gemini`. Beacon writes local OTLP settings to `~/.gemini/settings.json`, sets `target` to `local`, uses OTLP gRPC, enables the collector, and removes `outfile` so telemetry flows to Beacon. |-| [VS Code](/runtimes/vscode) | Optional with `--harness vscode`. Beacon writes Copilot Chat OTel settings to VS Code user settings and points OTLP/HTTP to the local collector. |+| [Gemini CLI](/runtimes/gemini-cli) | The default endpoint install detects Gemini and writes local OTLP settings to `~/.gemini/settings.json`, sets `target` to `local`, uses OTLP gRPC, enables the collector, and removes `outfile` so telemetry flows to Beacon. |+| [VS Code](/runtimes/vscode) | The default endpoint install detects VS Code, writes Copilot Chat OTel settings to VS Code user settings, points OTLP/HTTP to the local collector, and installs user-level hooks. || [GitHub Copilot CLI](/runtimes/github-copilot-cli) | Copilot's OTLP HTTP endpoint remains under MDM or customer-owned launch-environment policy. Beacon validates `COPILOT_OTEL_ENABLED=true` and a localhost OTLP endpoint but does not write Copilot configuration. Committed sessions can be backfilled with `beacon endpoint copilot sync`. || [Factory Droid](/runtimes/factory-droid) | Droid's OTLP endpoint remains under its launch environment, commonly managed through MDM or another customer-owned policy. Committed sessions can be backfilled with `beacon endpoint factory sync`. || [OpenClaw Gateway](/runtimes/openclaw-gateway) | Configure OpenClaw with the `diagnostics-otel` plugin. Beacon prints local OTLP/HTTP setup guidance and validates observed events. Committed session files can be backfilled with `beacon endpoint integrations openclaw sessions sync`. || [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), [DeepSeek Harness](/runtimes/deepseek-harness), [Devin CLI](/runtimes/devin), [Devin Desktop](/runtimes/devin-desktop), [Factory](/runtimes/factory-droid), [Grok Build](/runtimes/grok-build), [goose](/runtimes/goose), [Hermes Agent](/runtimes/hermes-agent), [Kimi Code](/runtimes/kimi-code), [Kiro](/runtimes/kiro), [Muse Code](/runtimes/muse-code), [Oh My Pi](/runtimes/oh-my-pi), [OpenCode](/runtimes/opencode), [OpenHands](/runtimes/openhands), [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. DeepSeek Harness and Kimi Code support user scope only. |+| Hook-based runtimes | The default endpoint install detects and configures supported user-level hooks and managed plugins for [Antigravity CLI](/runtimes/antigravity-cli), [Claude Code](/runtimes/claude-code), [Cline](/runtimes/cline), [Cursor](/runtimes/cursor), [DeepSeek Harness](/runtimes/deepseek-harness), [Devin CLI](/runtimes/devin), [Devin Desktop](/runtimes/devin-desktop), [Factory](/runtimes/factory-droid), [Grok Build](/runtimes/grok-build), [Hermes Agent](/runtimes/hermes-agent), [Kimi Code](/runtimes/kimi-code), [Kiro](/runtimes/kiro), [Muse Code](/runtimes/muse-code), [Oh My Pi](/runtimes/oh-my-pi), [OpenCode](/runtimes/opencode), [Pi](/runtimes/pi), and [Qwen Code](/runtimes/qwen-code). Use [`beacon endpoint hooks`](/cli/hooks) for explicit targets and project scope. OpenHands requires project scope for CLI/GUI coverage, and goose still has no installer. DeepSeek Harness and Kimi Code support user scope only. |## Integration paths