Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavior. It states the tool does not edit files, but it does not clarify whether registering an event has persistent side effects, requires authentication, or is effectively a read-only proposal. The word 'Register' implies mutation, yet the description leaves that ambiguity unresolved.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no filler: the first states the primary action and output, the second adds a key behavioral constraint. Information is front-loaded and each sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 6 parameters, no output schema, and no annotations, this description is incomplete. It omits side effects, response format, required parameter semantics, and any relationship to sibling tools. It is enough to identify the tool but not enough to call it confidently without inspecting the schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 33% (2 of 6 properties have descriptions), so the description should compensate, but it adds no parameter-level detail. The reference to window.clarvivo.trackEvent loosely suggests how name, type, and value might be used, but it does not explain url, where, or which parameters are required.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Register') with a specific resource ('a Clarvivo event') and explains that the tool proposes the exact window.clarvivo.trackEvent call and handler placement. It is clearly distinct from siblings because it is about event registration rather than installation or revenue setup, though it does not explicitly name an alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus siblings like setup_analytics, connect_revenue, or get_install_snippet. The only contextual clue is 'This tool does not edit files,' which communicates a limitation but not a selection rule or prerequisite.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the idempotentHint annotation, the description adds a meaningful behavioral constraint: it states that the tool never accepts or transmits webhook secrets. It also clarifies the output shape (three-step checklist and attribution edit), which is useful for an agent deciding whether the operation is safe and what to expect.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loads the core action, and includes only high-value details. The security invariant about webhook secrets is concise and earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter tool with no output schema, the description provides enough context: what action happens, how provider selection works, what output is returned, and an important security constraint. Minor gaps remain around unsupported-SDK handling, but the essential information for a correct call is present.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema describes projectId but not provider, giving 50% coverage. The description adds slight clarity by implying provider is optional via 'or use the named provider,' but it does not explain the enum values or the role of projectId beyond what the schema already states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses specific verbs and a clear resource: detect a payment SDK, connect its Clarvivo webhook, and return a setup checklist. This distinguishes it from sibling tools like verify_revenue or setup_analytics by making the connection/onboarding action explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use the tool: when a supported payment SDK is detected or a provider is named. However, it does not explicitly contrast with siblings such as verify_revenue or setup_analytics, and there is no direct when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The idempotentHint annotation already signals safe repeated calls, and the description adds the 'reusing an existing alert of the same type' behavior, which provides some transparency beyond the annotation. However, it does not clarify what happens to the existing alert (updated, replaced, ignored) or whether the operation is otherwise destructive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is one efficient sentence with no filler, and the core action is front-loaded. It loses a point because the phrase 'reusing an existing alert of the same type' is compressed to the point of ambiguity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and only a short description, an agent is left guessing what a successful call returns, what happens when an alert of the same type exists, and whether metrics/funnels must be configured beforehand. The description only partially explains the reuse behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema describes projectId and the type enum, but only 33% of parameters have schema descriptions. The description adds some meaning by framing type as 'traffic or conversion', but it does not explain threshold units, threshold meaning, or how the three enum values map to alert behavior. Given the low coverage, the description does not sufficiently compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource: it creates a traffic or conversion alert, which clearly distinguishes it from the sibling tools in this workspace (none of which are alert-specific). However, it is less explicit about whether the result is a brand-new alert or an update, which slightly weakens the clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies that this tool is for creating alerts and mentions reuse, but it does not state when to prefer this over other tools, nor does it explain prerequisites such as needing analytics or project setup first. No alternatives or exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide idempotentHint=true, but the description goes beyond that by explaining the mechanism: reusing a case-insensitive name match prevents duplicates. It also discloses the useful validation behavior of flagging steps without a known tracked page. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One dense, front-loaded sentence with no wasted words. Each clause adds meaningful behavior: creation, ordering, idempotent retry handling, and validation flagging.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a three-parameter creation tool with an idempotency annotation, the description covers ordering, retry safety, and a validation behavior. The main omission is the response/error shape, but the absence of an output schema makes that a minor gap rather than a blocking one.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 33%, and the description compensates partially by explaining that name matching is case-insensitive and that steps are ordered and checked against tracked pages. However, the step item fields (url and name) and the meaning of projectId are not elaborated beyond the minimal schema note, so compensation is incomplete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'Create an ordered funnel'. It also adds distinguishing behavior—idempotent case-insensitive name reuse and flagging of untracked steps—so the tool is clearly distinguished from sibling list/analytics/setup tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies this tool is for creating funnels and that retries are safe, but it does not explicitly name alternatives like list_funnels or state when NOT to use it. Routing among siblings is therefore left largely implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the useful detail that it returns exact snippet/file/placement/code, but it does not clarify behavior when neither apiKey nor projectId is provided, or whether one of them is required despite only framework being marked required in the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that front-loads the core output terms (snippet, target file, placement, framework-specific code). It is concise and informative, though it could be slightly clearer about the apiKey/projectId fallback behavior.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only retrieval tool with no output schema, the description communicates the main purpose and result content. It does not specify what happens if only framework is provided without an apiKey or projectId, nor does it mention whether the result is language-specific or how to handle multiple matches. The absence of output schema increases the burden on the description, which is only partially met.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so each parameter already has a description. The tool description adds that the parameters refer to an existing API key or project, reinforcing the relationship between apiKey/projectId and the returned snippet, but does not add new semantics beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Return') and names the exact resources and outputs: tracking snippet, target file, placement, and framework-specific code. It clearly identifies the tool as retrieving install instructions for an existing Clarvivo API key or project, distinguishing it from sibling tools like verify_installation or list_projects.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this is the tool to get framework-specific installation details, and the sibling names suggest alternatives like verify_installation for post-install checks. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites such as needing either apiKey or projectId to exist beforehand.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered by structured data. The description adds useful behavioral context beyond those annotations: the response is pre-summarised, contains an active visitor count, and limits pages/referrers to the top five rather than returning raw rows. This helps set expectations without contradicting the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single well-structured sentence that front-loads the main purpose and packs in the key output characteristics without filler. Every phrase earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only stats tool with fully documented parameters and safety annotations, the description provides enough output shape detail—active visitors, top pages/referrers, pre-summarised nature—to let an agent invoke it correctly and interpret the result. The lack of an output schema is adequately compensated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with both projectId and days fully documented including defaults, min/max, and types. The description adds no parameter-level meaning beyond the schema, so the baseline score applies; it neither harms nor enhances parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with the specific verb 'Return' and names a precise resource: a small pre-summarised traffic overview with active visitor count and top five pages/referrers. It also contrasts itself with raw daily analytics rows, making its purpose unmistakable and distinguishing it from the analytics-related siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'instead of raw daily analytics rows' gives clear contextual guidance about when to reach for this tool: when a compact summary is desired rather than granular daily data. However, it does not explicitly name an alternative tool or specify when not to use it, so it stops short of full routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The readOnlyHint and idempotentHint annotations already cover the safety profile. The description adds that funnels include 'ordered steps,' but it does not elaborate on the ordering semantics, response shape, or pagination. There is no contradiction with the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single compact sentence that front-loads the action and object. There is no wasted wording or redundant restatement of the title.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only, single-parameter list tool, the description plus the readOnly and idempotent annotations are nearly sufficient. It clearly states what is returned (funnels and ordered steps). A small gap remains around the exact response format and what 'ordered' means, but nothing essential is missing for selecting and invoking the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter projectId is fully described in the schema as 'Clarvivo project ID' (100% coverage). The description adds no additional parameter-specific meaning, so it does not need to compensate for missing schema information.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description starts with the specific verb 'List' and names the resource ('the project's funnels') plus a distinguishing detail ('and ordered steps'). This clearly separates it from siblings like create_funnel and list_projects.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The usage is implied by the verb and resource: an agent would use this when it needs to view existing funnels and their steps. However, the description does not explicitly state when to use this over alternatives or call out exclusions, leaving the guidance implicit rather than direct.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds value by noting 'accessible' projects (scoping) and specifying the response fields (IDs, domains, public tracking API keys), which clarifies what the agent can expect without needing an output schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, tightly written sentence that front-loads the core action and resource before listing the returned fields. Every word earns its place; there is no redundancy or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, read-only list operation, the description fully covers what the tool does and what it returns. Annotations cover safety, and no output schema is needed because the description enumerates the exact fields. Nothing an agent needs to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so there is nothing to document. The baseline for zero-parameter tools is 4, and the description correctly avoids inventing parameter details. It does not need to explain parameter semantics because none exist.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('List') and resource ('accessible Clarvivo projects') and enumerates the exact returned fields: IDs, domains, and public tracking API keys. This clearly distinguishes it from sibling tools like get_stats or create_funnel, which operate on different resources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: call this when you need an enumeration of accessible projects and their identifiers. However, it does not explicitly state when to use it over alternatives or mention any exclusions, so the guidance is only implicit, not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With idempotentHint=true, the description does not contradict the annotation. It adds meaningful behavioral context by disclosing that the tool may reuse or create a project and that its result is an exact file and code edit rather than a vague success message. This goes beyond what the annotation alone conveys.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences deliver the core action, the return value, and the tool-selection guidance with no filler. The most important operational detail, when to use it, is placed at the end of the second sentence but still earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema, so the description usefully states what is returned: an exact file and code edit. Combined with the schema-covering parameters and clear usage guidance, the tool is sufficiently specified for an agent to invoke it correctly. Minor gaps such as not describing the exact return shape prevent a 5.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents domain, name, and framework clearly. The description adds little parameter-level meaning beyond mentioning 'for a domain,' so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb chain with a clear resource: detect the repository's framework, reuse or create the Clarvivo project, and return an exact file/code edit. It is clearly distinct from siblings such as get_install_snippet or verify_installation, and the phrase 'Use this first when asked to add analytics' removes ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says to use this tool first when asked to add analytics, establishing a clear trigger condition and ordering relative to siblings. It does not enumerate when-not-to-use cases or alternatives, but the guidance is still unambiguous for the primary scenario.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint and idempotentHint, lowering the burden. The description adds useful behavioral context: it uses a 'proof-of-life receipt' rather than reading analytics or sending synthetic traffic, which clarifies the mechanism and reinforces the safe, non-intrusive nature of the call.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, well-constructed sentence that front-loads the core action and includes the key exclusions. Every word contributes meaning; there is no fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter tool with safety-critical annotations already present, the description sufficiently covers purpose, mechanism, and exclusions. No output schema exists, so no return-value details are required; the description gives enough for an agent to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% — the only parameter, projectId, is described as 'Clarvivo project ID' in the schema. The description does not add parameter-level detail beyond that, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Uses a specific verb ('Check') tied to a concrete resource ('Clarvivo's proof-of-life receipt') and states exactly what it confirms: traffic from the deployed site has arrived. Also differentiates itself from siblings by explicitly excluding analytics reads and synthetic event generation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description makes clear when this tool is appropriate: to verify installation without touching analytics or emitting synthetic events. This implies when not to use it (e.g., use get_stats for analytics reads), though it does not explicitly name alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds meaningful behavioral context by guaranteeing that no revenue amounts or customer data are returned, which is an important privacy/redaction behavior beyond what annotations alone convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, concise sentence that front-loads the primary action and includes the key limitation immediately. Every phrase contributes meaningful information with no redundancy or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter read-only tool, the description is nearly complete. It covers intent, scope, and safety constraints; the only minor gap is that it does not explicitly state what the tool returns (e.g., a boolean or status object), which would help since there is no output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema coverage is 100%, with projectId already described as 'Clarvivo project ID'. The description does not add further parameter-level detail, so the schema carries the semantic weight and the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Check') and resource ('payment webhook') and adds two precise dimensions: proof-of-life and attribution coverage. It also explicitly excludes returning revenue amounts or customer data, which clearly differentiates it from revenue-related siblings like connect_revenue.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description conveys clear context: use this when you need to verify payment webhook liveness and attribution coverage. It does not explicitly name alternatives or state when not to use it, but the scope is specific enough to distinguish it from sibling tools like verify_installation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.