Skip to content

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

Read npm exec options after the package; decide Beacon's own by definition

Claude94d796bb8fe5
diff --git a/cli/beacon/internal/agentskills/agentskills.go b/cli/beacon/internal/agentskills/agentskills.go
index 8381ab54..10ba750b 100644
--- a/cli/beacon/internal/agentskills/agentskills.go
+++ b/cli/beacon/internal/agentskills/agentskills.go
@@ -141,6 +141,13 @@ func Uninstall(roots []string) []Result {
return out
}
+// Managed reports whether dir is a skill directory Beacon wrote: a real directory carrying
+// Beacon's marker.
+func Managed(dir string) bool {
+ managed, _, err := inspect(dir)
+ return err == nil && managed
+}
+
func inspect(dir string) (managed, exists bool, err error) {
info, err := os.Lstat(dir)
if errors.Is(err, os.ErrNotExist) {
diff --git a/cli/beacon/internal/intel/installed.go b/cli/beacon/internal/intel/installed.go
index 62e59786..b3cee535 100644
--- a/cli/beacon/internal/intel/installed.go
+++ b/cli/beacon/internal/intel/installed.go
@@ -67,19 +67,29 @@ type FromInventoryOptions struct {
// Registries is what the machine's launcher configuration says about registries and
// indexes (LocalRegistries); a package it may route elsewhere is held back as private.
Registries Registries
- // BeaconSkills are skill names Beacon installs itself (agentskills.Names), never checked.
- BeaconSkills []string
+ // BeaconSkill reports whether a skill is one Beacon installed itself (an agentskills name
+ // in a directory carrying Beacon's marker), never checked. A skill that only shares the
+ // name is checked like any other.
+ BeaconSkill func(inventory.Skill) bool
}
-var beaconServers = map[string]bool{"beacon": true, "beacon-managed": true}
+// beaconServer reports whether a configured server is Beacon's own: the local `beacon` server
+// (the beacon binary) or Beacon Cloud MCP (`beacon-managed`, a URL with no command). A server
+// that only takes one of the names is checked like any other.
+func beaconServer(name, command string, args []string, s inventory.MCPServer) bool {
+ switch strings.ToLower(name) {
+ case "beacon":
+ program, _ := launcher(command, args)
+ return launcherBase(program) == "beacon"
+ case "beacon-managed":
+ return s.URLPresent && !s.CommandPresent && command == ""
+ }
+ return false
+}
// FromInventory turns an inventory scan into deduplicated lookups, servers first, each list in
// a stable order.
func FromInventory(res inventory.Result, opts FromInventoryOptions) ([]Installed, []Skipped) {
- beaconSkills := map[string]bool{}
- for _, name := range opts.BeaconSkills {
- beaconSkills[name] = true
- }
byKey := map[string]*Installed{}
var order []string
var skipped []Skipped
@@ -102,11 +112,11 @@ func FromInventory(res inventory.Result, opts FromInventoryOptions) ([]Installed
for _, s := range res.MCPServers {
name := strings.TrimSpace(s.ServerName)
src := InstalledSource{Runtime: s.Runtime, Name: name, Scope: s.SourceScope}
- if beaconServers[strings.ToLower(name)] {
+ command, args := commandOf(s.Definition)
+ if beaconServer(name, command, args, s) {
skipped = append(skipped, Skipped{Kind: "mcp", Runtime: s.Runtime, Name: name, Reason: ReasonBeacon})
continue
}
- command, args := commandOf(s.Definition)
if q, basis, ok := PackageFromCommand(command, args); ok {
program, programArgs := launcher(command, args)
if registryFromEnv(s.Definition) || opts.Registries.forServer(program, programArgs, s.Definition).private(q) {
@@ -135,7 +145,7 @@ func FromInventory(res inventory.Result, opts FromInventoryOptions) ([]Installed
if !s.Exists {
continue
}
- if beaconSkills[name] {
+ if opts.BeaconSkill != nil && opts.BeaconSkill(s) {
skipped = append(skipped, Skipped{Kind: "skill", Runtime: s.Runtime, Name: name, Reason: ReasonBeacon})
continue
}
@@ -280,7 +290,8 @@ func PackageFromCommand(command string, args []string) (q, basis string, ok bool
if len(rest) == 0 || (rest[0] != "exec" && rest[0] != "x") {
return "", "", false
}
- rest = rest[1:]
+ // npm exec and npm x read npm's options after the package too, up to --.
+ return npmFrom(rest[1:], true)
case "uvx":
return pypiFrom(rest)
case "pipx":
@@ -296,7 +307,7 @@ func PackageFromCommand(command string, args []string) (q, basis string, ok bool
default:
return "", "", false
}
- return npmFrom(rest)
+ return npmFrom(rest, false)
}
// The options a launcher takes before the package it runs. A flag in neither list stops the
@@ -336,11 +347,19 @@ func flagSet(flags ...string) map[string]bool {
// argument that is not an option. ok is false when an unknown option makes that uncertain.
// private reports whether a flag in privateFlags appeared anywhere among the launcher's own
// options, including after a package flag: `uvx --from pkg --index-url <url> cmd` fetches pkg
-// from that index too.
-func packageArg(args []string, packageFlags, valueFlags, boolFlags, privateFlags map[string]bool) (spec string, private, ok bool) {
- found := false
+// from that index too. With optionsAnywhere (npm exec and npm x), the launcher's options run
+// past the first plain word up to --, so they are read there too: a registry or package flag
+// after the package still counts, and an unknown option still stops the parse.
+func packageArg(args []string, packageFlags, valueFlags, boolFlags, privateFlags map[string]bool, optionsAnywhere bool) (spec string, private, ok bool) {
+ found, positional := false, false
for i := 0; i < len(args); i++ {
a := args[i]
+ if a == "--" && optionsAnywhere {
+ if !found && !positional && i+1 < len(args) {
+ spec, positional = args[i+1], true
+ }
+ break
+ }
name, value, hasValue := strings.Cut(a, "=")
if !strings.HasPrefix(a, "-") {
hasValue = false
@@ -374,20 +393,25 @@ func packageArg(args []string, packageFlags, valueFlags, boolFlags, privateFlags
case boolFlags[a]:
case strings.HasPrefix(a, "-"):
return "", private, false
+ case positional:
+ // A later plain word is an argument to the command.
default:
// The first plain word is the package, or the command a package flag's package
- // provides; either way the launcher's options end here.
+ // provides; for every launcher but npm exec, the launcher's options end here.
if !found {
spec = a
}
- return spec, private, true
+ if !optionsAnywhere {
+ return spec, private, true
+ }
+ positional = true
}
}
- return spec, private, found
+ return spec, private, found || positional
}
-func npmFrom(args []string) (string, string, bool) {
- spec, private, ok := packageArg(args, npmPackageFlags, npmValueFlags, npmBoolFlags, npmPrivateFlags)
+func npmFrom(args []string, optionsAnywhere bool) (string, string, bool) {
+ spec, private, ok := packageArg(args, npmPackageFlags, npmValueFlags, npmBoolFlags, npmPrivateFlags, optionsAnywhere)
if !ok {
return "", "", false
}
@@ -433,7 +457,7 @@ func npmPackage(spec string) (string, string, bool) {
}
func pypiFrom(args []string) (string, string, bool) {
- spec, private, ok := packageArg(args, pypiPackageFlags, pypiValueFlags, pypiBoolFlags, pypiPrivateFlags)
+ spec, private, ok := packageArg(args, pypiPackageFlags, pypiValueFlags, pypiBoolFlags, pypiPrivateFlags, false)
if !ok {
return "", "", false
}
diff --git a/cli/beacon/internal/intel/installed_test.go b/cli/beacon/internal/intel/installed_test.go
index 5601db93..0e092811 100644
--- a/cli/beacon/internal/intel/installed_test.go
+++ b/cli/beacon/internal/intel/installed_test.go
@@ -25,6 +25,13 @@ func TestPackageFromCommand(t *testing.T) {
{"pnpm", []string{"dlx", "@x/y@2"}, "npm:@x/y"},
{"yarn", []string{"dlx", "z"}, "npm:z"},
{"npm", []string{"exec", "--", "[email protected]"}, "npm:w"},
+ {"npm", []string{"exec", "[email protected]", "--yes"}, "npm:w"},
+ {"npm", []string{"exec", "w", "--", "--port", "3000"}, "npm:w"},
+ {"npm", []string{"x", "w", "positional-arg"}, "npm:w"},
+ // npm exec reads its options after the package word, so --package there names the
+ // package npm installs and the plain word is the command it provides.
+ {"npm", []string{"exec", "bar", "--package=@scope/foo"}, "npm:@scope/foo"},
+ {"npm", []string{"exec", "bar", "-p", "@scope/foo"}, "npm:@scope/foo"},
{"uvx", []string{"mcp-server-fetch"}, "pypi:mcp-server-fetch"},
{"uvx", []string{"--python", "3.12", "Mcp_Server.Time==1.2"}, "pypi:mcp_server.time"},
{"uvx", []string{"--from", "awslabs.aws-docs-mcp-server[cli]>=1", "aws-docs"}, "pypi:awslabs.aws-docs-mcp-server"},
@@ -69,6 +76,10 @@ func TestPackageFromCommand(t *testing.T) {
{"npx", []string{"--mystery", "value", "pkg"}},
{"npx", []string{"--mystery=value", "pkg"}},
{"npx", []string{"-c", "echo hi"}},
+ // npm exec would read an option after the package as its own, so one Beacon does not
+ // know still stops the parse there.
+ {"npm", []string{"exec", "pkg", "--mystery", "value"}},
+ {"npm", []string{"exec", "pkg", "--@acme:registry=https://npm.acme.internal"}},
{"", nil},
} {
if q, _, ok := PackageFromCommand(tc.command, tc.args); ok {
@@ -105,7 +116,8 @@ func TestFromInventorySendsOnlyPublicIdentifiers(t *testing.T) {
{Runtime: "claude_code", SkillName: "/Users/me/skills/x", SourceScope: "user", Exists: true},
},
}
- items, skipped := FromInventory(res, FromInventoryOptions{BeaconSkills: []string{"beacon-memory-recall"}})
+ beaconSkill := func(s inventory.Skill) bool { return s.SkillName == "beacon-memory-recall" }
+ items, skipped := FromInventory(res, FromInventoryOptions{BeaconSkill: beaconSkill})
var got []string
for _, item := range items {
@@ -142,7 +154,7 @@ func TestFromInventorySendsOnlyPublicIdentifiers(t *testing.T) {
}
// With consent, skills go by name, once for every runtime they are in.
- withNames, _ := FromInventory(res, FromInventoryOptions{IncludePrivateNames: true, BeaconSkills: []string{"beacon-memory-recall"}})
+ withNames, _ := FromInventory(res, FromInventoryOptions{IncludePrivateNames: true, BeaconSkill: beaconSkill})
last := withNames[len(withNames)-1]
if last.Kind != "skill" || last.Q != "pdf" || len(last.Sources) != 2 || last.Basis != BasisSkillName {
t.Fatalf("pdf with consent = %+v", last)
@@ -177,6 +189,15 @@ func TestPrivateRegistriesAndWindowsShells(t *testing.T) {
{"uvx", []string{"--from=acme-billing-mcp", "--index=https://pypi.acme.internal/simple", "acme-billing"}, "pypi:acme-billing-mcp", BasisPrivatePyPI},
{"npx", []string{"-p", "@acme/mcp", "--registry", "https://npm.acme.internal", "acme-mcp"}, "npm:@acme/mcp", BasisPrivateNPM},
{"npx", []string{"--package=@acme/mcp", "--registry=https://npm.acme.internal", "acme-mcp"}, "npm:@acme/mcp", BasisPrivateNPM},
+ // npm exec reads a registry or config file named after the package too, up to --.
+ {"npm", []string{"exec", "@acme/internal-mcp", "--registry=https://npm.acme.internal"}, "npm:@acme/internal-mcp", BasisPrivateNPM},
+ {"npm", []string{"x", "@acme/internal-mcp", "--registry", "https://npm.acme.internal"}, "npm:@acme/internal-mcp", BasisPrivateNPM},
+ {"npm", []string{"exec", "@acme/internal-mcp", "--userconfig", "/x/.npmrc"}, "npm:@acme/internal-mcp", BasisPrivateNPM},
+ {"npm", []string{"exec", "bar", "--package=@acme/foo", "--registry=https://npm.acme.internal"}, "npm:@acme/foo", BasisPrivateNPM},
+ // After -- the words are the command's, not npm's.
+ {"npm", []string{"exec", "w", "--", "--registry=https://npm.acme.internal"}, "npm:w", BasisNPM},
+ // npx stops at the package word: what follows is the command's.
+ {"npx", []string{"-y", "pkg", "--registry=https://elsewhere.example"}, "npm:pkg", BasisNPM},
{"uvx", []string{"--from", "mcp-server-fetch", "mcp-server-fetch"}, "pypi:mcp-server-fetch", BasisPyPI},
// A config file or pip's own arguments can name an index or registry.
{"npx", []string{"--userconfig", "/x/.npmrc", "@acme/mcp"}, "npm:@acme/mcp", BasisPrivateNPM},
@@ -209,6 +230,42 @@ func TestPrivateRegistriesAndWindowsShells(t *testing.T) {
}
}
+func TestFromInventoryKnowsBeaconByDefinitionNotName(t *testing.T) {
+ res := inventory.Result{
+ MCPServers: []inventory.MCPServer{
+ server("claude_code", "beacon", "user", map[string]interface{}{"command": "/opt/beacon/bin/beacon", "args": []interface{}{"mcp", "serve"}}),
+ server("codex", "beacon-managed", "user", map[string]interface{}{"url": "https://beacon.sh/mcp"}),
+ // Servers that only take Beacon's names are checked like any other.
+ server("cursor", "beacon", "user", map[string]interface{}{"command": "npx", "args": []interface{}{"-y", "some-pkg"}}),
+ server("cursor", "BEACON-MANAGED", "project", map[string]interface{}{"command": "uvx", "args": []interface{}{"other-pkg"}}),
+ },
+ Skills: []inventory.Skill{
+ {Runtime: "claude_code", SkillName: "beacon-memory-recall", ManifestPath: "/home/me/.claude/skills/beacon-memory-recall/SKILL.md", SourceScope: "user", Exists: true},
+ {Runtime: "codex", SkillName: "beacon-memory-recall", ManifestPath: "/home/me/project/.agents/skills/beacon-memory-recall/SKILL.md", SourceScope: "project", Exists: true},
+ },
+ }
+ beaconSkill := func(s inventory.Skill) bool {
+ return s.ManifestPath == "/home/me/.claude/skills/beacon-memory-recall/SKILL.md"
+ }
+ items, skipped := FromInventory(res, FromInventoryOptions{IncludePrivateNames: true, BeaconSkill: beaconSkill})
+ var got []string
+ for _, item := range items {
+ got = append(got, item.Kind+" "+item.Q+" "+item.Sources[0].Runtime)
+ }
+ if strings.Join(got, ", ") != "mcp npm:some-pkg cursor, mcp pypi:other-pkg cursor, skill beacon-memory-recall codex" {
+ t.Fatalf("items = %v", got)
+ }
+ var beacon []string
+ for _, s := range skipped {
+ if s.Reason == ReasonBeacon {
+ beacon = append(beacon, s.Kind+" "+s.Runtime+" "+s.Name)
+ }
+ }
+ if strings.Join(beacon, ", ") != "mcp claude_code beacon, mcp codex beacon-managed, skill claude_code beacon-memory-recall" {
+ t.Fatalf("Beacon's own = %v (skipped %+v)", beacon, skipped)
+ }
+}
+
func TestPackageFromCommandRefusesSpecsOffTheRegistry(t *testing.T) {
for _, tc := range []struct {
command string
diff --git a/cli/beacon/internal/mcpserver/intel_tools.go b/cli/beacon/internal/mcpserver/intel_tools.go
index b1e2374c..5832721c 100644
--- a/cli/beacon/internal/mcpserver/intel_tools.go
+++ b/cli/beacon/internal/mcpserver/intel_tools.go
@@ -5,6 +5,8 @@ import (
"encoding/json"
"fmt"
"os"
+ "path/filepath"
+ "strings"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/agentskills"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/inventory"
@@ -200,7 +202,7 @@ func (s *Server) checkInstalled(ctx context.Context, args map[string]interface{}
items, skipped := intel.FromInventory(inv, intel.FromInventoryOptions{
IncludePrivateNames: a.includePrivateNames,
Registries: intel.LocalRegistries(registryEnv()),
- BeaconSkills: agentskills.Names(),
+ BeaconSkill: beaconSkill(agentskills.Names()),
})
report := installedReport{Sent: make([]intelapi.CheckItem, len(items)), Skipped: skipped}
if report.Skipped == nil {
@@ -244,7 +246,10 @@ func (s *Server) checkInstalled(ctx context.Context, args map[string]interface{}
}
// A name, or a package or repository the index fell back to matching as a name, may
// be a different artifact that shares it.
- byName := item.Basis == intel.BasisSkillName || item.Basis == intel.BasisServerName || outcome.MatchedBy == "text"
+ // A package from a private registry or index is matched against the public package
+ // that shares its name, which may be a different artifact too.
+ byName := item.Basis == intel.BasisSkillName || item.Basis == intel.BasisServerName ||
+ item.Basis == intel.BasisPrivateNPM || item.Basis == intel.BasisPrivatePyPI || outcome.MatchedBy == "text"
if outcome.Status == "matched" && byName {
result.NameOnly = true
result.Guidance = nameOnlyGuidance + result.Guidance
@@ -261,6 +266,18 @@ func (s *Server) checkInstalled(ctx context.Context, args map[string]interface{}
return report, nil
}
+// beaconSkill reports whether an inventoried skill is one Beacon installed: one of its skill
+// names, in a directory carrying Beacon's marker.
+func beaconSkill(names []string) func(inventory.Skill) bool {
+ known := map[string]bool{}
+ for _, name := range names {
+ known[name] = true
+ }
+ return func(s inventory.Skill) bool {
+ return known[strings.TrimSpace(s.SkillName)] && s.ManifestPath != "" && agentskills.Managed(filepath.Dir(s.ManifestPath))
+ }
+}
+
// intelTools lists the Beacon Intel tools, for doctor and tests.
func intelTools() []string {
return []string{intelToolNames.Lookup, intelToolNames.GetArtifact, intelToolNames.Check, "intel_check_installed"}
diff --git a/cli/beacon/internal/mcpserver/intel_tools_test.go b/cli/beacon/internal/mcpserver/intel_tools_test.go
index 720b902c..2d36c739 100644
--- a/cli/beacon/internal/mcpserver/intel_tools_test.go
+++ b/cli/beacon/internal/mcpserver/intel_tools_test.go
@@ -13,6 +13,7 @@ import (
"sync"
"testing"
+ "github.com/asymptote-labs/agent-beacon/cli/beacon/internal/agentskills"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/inventory"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/intel"
"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve/intelapi"
@@ -210,11 +211,16 @@ func fakeInventory(nServers int) inventory.Result {
func TestIntelCheckInstalledDryRunSendsNothing(t *testing.T) {
s, f := newIntelServer(t, func(string, string) (int, string) { return 500, "" })
+ // Beacon's own skill is the one it installed, marker and all.
+ skills := t.TempDir()
+ agentskills.Install([]string{skills})
s.inventory = func(includeProject bool) inventory.Result {
if includeProject {
t.Error("include_project false was not passed through")
}
- return fakeInventory(2)
+ inv := fakeInventory(2)
+ inv.Skills[1].ManifestPath = filepath.Join(skills, "beacon-memory-recall", "SKILL.md")
+ return inv
}
text, isErr := call(t, s, "intel_check_installed", map[string]interface{}{"dry_run": true, "include_project": false})
if isErr {
@@ -435,9 +441,11 @@ func TestIntelCheckInstalledHoldsBackAScopeFromTheUsersNpmrc(t *testing.T) {
func TestIntelCheckInstalledMarksNameMatches(t *testing.T) {
s, f := newIntelServer(t, func(path, body string) (int, string) {
- // The package matched nothing, so the index matched its text against names; the skill
+ // The private-registry package matched the public package that shares its name; the
+ // public package matched nothing, so the index matched its text against names; the skill
// matched by name.
return 200, `{"api":"intel.v1","results":[
+ {"q":"npm:internal-tool","matched_by":"package","status":"matched","risk":"benign","guidance":"No issues found.","matches":[{"entity_key":"mcp:public/internal-tool"}]},
{"q":"npm:some-mcp","matched_by":"text","status":"matched","risk":"benign","guidance":"No issues found.","matches":[{"entity_key":"mcp:other/some-mcp"}]},
{"q":"pdf","matched_by":"text","status":"matched","risk":"benign","guidance":"No issues found.","matches":[{"entity_key":"skill:a/b#pdf"}]}
],"counts":{}}`
@@ -445,7 +453,10 @@ func TestIntelCheckInstalledMarksNameMatches(t *testing.T) {
s.inventory = func(bool) inventory.Result {
return inventory.Result{
MCPServers: []inventory.MCPServer{{Runtime: "cursor", ServerName: "x", SourceScope: "user", CommandPresent: true,
- Definition: map[string]interface{}{"command": "npx", "args": []interface{}{"-y", "some-mcp"}}}},
+ Definition: map[string]interface{}{"command": "npx", "args": []interface{}{"-y", "some-mcp"}}},
+ // A package from a private registry matched the public package of the same name.
+ {Runtime: "cursor", ServerName: "y", SourceScope: "user", CommandPresent: true,
+ Definition: map[string]interface{}{"command": "npx", "args": []interface{}{"--registry", "https://npm.corp.example", "-y", "internal-tool"}}}},
Skills: []inventory.Skill{{Runtime: "claude_code", SkillName: "pdf", SourceScope: "user", Exists: true}},
}
}
@@ -457,9 +468,40 @@ func TestIntelCheckInstalledMarksNameMatches(t *testing.T) {
if err := json.Unmarshal([]byte(text), &report); err != nil {
t.Fatal(err)
}
+ if len(report.Results) != 3 {
+ t.Fatalf("results = %+v", report.Results)
+ }
for _, r := range report.Results {
if !r.NameOnly || !strings.HasPrefix(r.Guidance, "Matched by name only") || !strings.HasSuffix(r.Guidance, "No issues found.") {
t.Errorf("%s = %+v, want name_only", r.Q, r)
}
}
}
+
+func TestBeaconSkillNeedsBeaconsMarker(t *testing.T) {
+ root := t.TempDir()
+ for _, r := range agentskills.Install([]string{root}) {
+ if r.Err != nil {
+ t.Fatal(r.Err)
+ }
+ }
+ names := agentskills.Names()
+ if len(names) == 0 {
+ t.Fatal("no embedded skills")
+ }
+ // A skill a person wrote under one of Beacon's names has no marker.
+ other := filepath.Join(t.TempDir(), names[0])
+ if err := os.MkdirAll(other, 0o755); err != nil {
+ t.Fatal(err)
+ }
+ isBeacon := beaconSkill(names)
+ if !isBeacon(inventory.Skill{SkillName: names[0], ManifestPath: filepath.Join(root, names[0], "SKILL.md")}) {
+ t.Error("Beacon's installed skill was not recognized")
+ }
+ if isBeacon(inventory.Skill{SkillName: names[0], ManifestPath: filepath.Join(other, "SKILL.md")}) {
+ t.Error("a skill that only shares Beacon's name was taken for Beacon's")
+ }
+ if isBeacon(inventory.Skill{SkillName: "pdf", ManifestPath: filepath.Join(root, names[0], "SKILL.md")}) {
+ t.Error("a skill with another name was taken for Beacon's")
+ }
+}
diff --git a/docs/cli/intel.mdx b/docs/cli/intel.mdx
index 08e767ca..0496fbc1 100644
--- a/docs/cli/intel.mdx
+++ b/docs/cli/intel.mdx
@@ -126,7 +126,8 @@ in a server's launch command, without its version. For example, `npx -y @playwri
is sent as `npm:@playwright/mcp`, `uvx mcp-server-fetch` as `pypi:mcp-server-fetch`, and the
Windows form `cmd /c npx -y @playwright/mcp` the same way. A launch command with an option
Beacon does not recognize is skipped rather than guessed at, so an option's value is never sent
-as a package. So is a package that does not come from a registry: a git or tarball URL, a direct
+as a package. `npm exec` and `npm x` read npm's options after the package too (up to `--`), so
+Beacon reads them there as well. So is a package that does not come from a registry: a git or tarball URL, a direct
reference such as `name @ git+https://…`, an `npm:` alias, a path or a local wheel or tarball.
Names that may be private are held back and listed as skipped unless the agent passes
@@ -147,8 +148,11 @@ Names that may be private are held back and listed as skipped unless the agent p
- skill names, since a skill may be one you wrote.
Paths, URLs, environment variables and other arguments are never sent. Beacon's own server and
-skills are skipped. A result matched only by a name, including a package the index could only
-match by name, is marked `name_only`: it may be a different artifact with the same name, so
+skills are skipped: the `beacon` server that runs the `beacon` binary, the `beacon-managed`
+Beacon Cloud MCP entry, and skills Beacon installed. A server or skill that only shares one of
+those names is checked like any other. A result matched only by a name, including a package the
+index could only match by name and a package from a private registry or index (the index knows
+only the public package that shares its name), is marked `name_only`: it may be a different artifact with the same name, so
confirm the repository before relying on it. `dry_run` returns exactly what would be sent and
sends nothing. Results map back to every runtime and config where each artifact was found.