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

There are no annotations, so the description carries the full behavioral disclosure burden. It explicitly states that the tool does not rewrite and that a missing actionlint results in status='skipped'. This gives meaningful context about side effects and fallback behavior beyond the schema. It does not cover all possible behaviors, but for a check-only tool this is solid disclosure.

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 purpose and then adds the key behavioral detail about actionlint. Every part contributes information; there is no filler or repetition.

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 an output schema, the description covers purpose, non-destructive behavior, and a notable edge case. However, it leaves path semantics underspecified and does not distinguish this tool from siblings such as rush_lint or rush_ci. It is adequate but not complete for confident selection and invocation.

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 0%, and the description does not explain the path parameter. While 'check GitHub Actions workflows' implies path points to workflow files or a repo, it does not specify whether path should be a file, directory, or repository root, nor what happens when path is invalid. The description fails to compensate for the schema's lack of parameter documentation.

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 and resource: 'Check GitHub Actions workflows'. The qualifier 'without rewriting' adds useful scope and helps distinguish it from formatting or rewrite-style tools. It does not explicitly name sibling alternatives, but the resource is unambiguous enough for an agent to identify what it operates on.

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 'without rewriting' implies this is a non-mutating check tool, but the description gives no explicit when-to-use or when-not-to-use guidance. Among siblings like rush_lint, rush_ci, and rush_yaml, the choice is left to inference rather than stated.

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 no annotations, the description carries the full burden of behavioral disclosure, but it only restates high-level verbs. It doesn't say whether connecting is read-only, whether it scans local processes or files, whether authentication is needed, or what side effects discovery/diagnosis might have.

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 sentence is short, but it is under-specified rather than concise. It omits essential invocation detail and reads more like a marketing tagline than a functional specification.

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?

Despite the presence of an output schema, the description leaves the input contract entirely unknown. With only a generic request object and no behavioral detail, the tool is not callable based on this definition alone.

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 has one required 'request' object with additionalProperties: true and 0% schema description coverage. The description provides no hints about what fields the request should contain, so an agent cannot construct a valid invocation.

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 three active verbs—Discover, connect, and diagnose—against a clear resource: local coding agents. This distinguishes the tool from most generic rush_* siblings, though it doesn't explicitly name a sibling 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?

No guidance is given about when to choose this tool over related siblings such as rush_doctor, rush_context_retrieve, or rush_scan. There are no usage conditions, exclusions, or alternative tool pointers.

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 no annotations, the description carries the full burden. It adds one behavioral detail (permissions for live inference runs) but does not disclose side effects, what the evaluation does with the path, or the implications of the allow_* flags. This is minimal disclosure for a potentially impactful tool.

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 brief, front-loaded with the action, and has no redundant words. However, it is so short that it omits crucial context, so it is concise but not optimally structured for completeness.

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 8 parameters, 0% schema coverage, and no annotations, the description is severely incomplete. It does not explain what 'path' points to, what each allow flag controls, when to use this tool versus siblings, or how the evaluation is performed. The output schema does not compensate for the missing parameter and usage details.

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 0%, and the description does not explain any of the 8 parameters. The required 'path' parameter is undefined, and the boolean allow_* flags (allow_slow, allow_build, allow_browser, etc.) are entirely unexplained, leaving the agent without semantic guidance.

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 clear action ('Evaluate') and identifies specific target resources: LLM prompts, agent workflows, and safety guardrails. It does not explicitly differentiate from overlapping siblings like rush_prompt_eval, but the purpose is clear enough to distinguish from generic 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 provides no guidance on when to use this tool versus alternatives. 'Requires explicit permissions for live inference runs' is a prerequisite, not a usage criterion, and no sibling tools are mentioned for comparison.

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?

No annotations are provided, so the description carries the full burden. It implies a read-only detection operation ('Detect'), but it does not explicitly state side effects, permissions, or any behavioral nuances beyond the core action. It does not disclose return format (though an output schema exists) or failure conditions, leaving the agent to infer safety.

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, clear sentence with no waste. It front-loads the verb and resource, and the phrase 'against base Git ref' efficiently conveys the key parameter context. This is a model of conciseness.

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?

Given the tool's simplicity (one optional parameter, an output schema available), the description is largely adequate. It tells the agent what the tool does and implies how to use it. However, it omits any guidance on when to use this tool over other API-related tools in the large sibling set, and it does not mention any prerequisites or limitations. Still, for a straightforward detection tool, this is acceptable.

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 coverage is 0% (no descriptions in the input schema), so the description must compensate. It mentions 'against base Git ref', which clarifies that the 'base' parameter is a Git ref, adding meaning beyond the bare schema. However, it does not explicitly explain that 'base' is optional or describe its default behavior beyond what the schema already shows, so the added value is modest.

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 clearly states the tool's specific purpose: detecting breaking public API changes against a base Git ref. It uses a specific verb ('Detect') and a specific resource ('breaking public API changes'), and it distinguishes itself from siblings like rush_tui_diff (UI diff) and rush_db_drift (database drift) by focusing on API compatibility.

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 you need to check for breaking API changes against a Git ref), but it does not explicitly mention when to prefer it over alternatives or when not to use it. Given the large sibling set, this lack of explicit exclusions leaves some ambiguity for the agent.

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?

No annotations are provided, so the description carries the full burden of disclosing side effects and behavior. It only states the validation action without saying whether the tool is read-only, modifies files, requires permissions, or how it reports results. The word 'validate' suggests non-mutating behavior, but the name 'guard' could imply blocking, leaving ambiguity.

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 with no filler words; the core action and scope are front-loaded. It is as concise as possible while conveying the essential purpose.

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?

The tool has no parameters and an output schema exists, so the description does not need to cover arguments or return structure. However, it lacks context about scope (e.g., whole repository vs. changed files), required configuration, or typical invocation scenarios, leaving some gaps for an agent deciding when to invoke it.

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 tool accepts zero parameters and the schema is empty with 100% coverage. The description correctly has no parameter-specific details to add; the baseline 4 for zero-parameter tools 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 uses a specific verb ('validate') and a specific resource/scope ('codebase against clean architecture layer boundaries'), making the tool's function clear. It does not explicitly differentiate from siblings such as rush_lint or rush_complexity, but the unique focus on layer boundaries gives it a reasonably distinct purpose.

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 gives no guidance on when to use this tool instead of other rush_* tools, no prerequisites, and no exclusions. It does not mention typical invocation contexts (e.g., before a commit, after architecture changes) or alternatives to consider.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It states the output is an 'unsigned draft', which is useful, but it does not mention potential side effects such as building artifacts, network access, browser use, or file writes—concerns implied by the many 'allow_*' parameters. This lack of disclosure leaves significant behavioral uncertainty.

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, tight sentence with no filler or redundancy. The key information—what is generated and in what form—is front-loaded. It earns high marks for efficiency, though the brevity comes at the cost of completeness.

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?

This is a complex tool with 15 parameters, no schema descriptions, no annotations, and a detailed but undocumented parameter set. The description does not cover prerequisites, side effects, parameter meaning, or even the difference from the sibling 'rush_attest_generate'. An agent cannot reliably invoke this tool correctly based solely on this definition.

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 0%, and the description offers no explanation of any of the 15 parameters. It does not help an agent understand the meaning or relationship of 'path', 'artifact_path', 'output_path', 'allow_*' flags, or 'trusted_roots'. Since the schema itself has no descriptions, the description needed to compensate but did not.

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 specifies a clear verb ('Generate') and resource ('in-toto Statement v1 SLSA provenance unsigned draft for build artifacts'). It names the exact output format and the 'unsigned draft' qualifier, which distinguishes it from a signed attestation. Though it does not explicitly differentiate from the sibling 'rush_attest_generate', the purpose is concrete and actionable.

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 provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or sibling tools. An agent must infer usage solely from the tool name and sibling list, which is insufficient for correct tool selection.

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?

No annotations are provided, so the description carries the full behavioral burden. It only discloses deprecation status and equivalence to rush_attest; it does not describe side effects, permissions, rate limits, or any concrete execution behavior.

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 with no filler, front-loading the deprecation status and the alias target. For a deprecated alias, this is an appropriately concise and clear structure.

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?

The redirect information is sufficient for a deprecated stub, but the tool has 15 parameters, no annotations, and zero schema descriptions. If an agent ever needed to invoke this alias directly, it would lack almost all context about parameter behavior and tool side effects.

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 0% and there are 15 parameters, yet the description provides no semantic information about any of them. The agent gets no help understanding path, verify, allow_* flags, or other settings from the description.

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 clearly identifies the tool as a deprecated alias for rush_attest, which distinguishes it from siblings, but it never states what rush_attest actually does. The agent can infer the tool's behavior only indirectly from the sibling name, leaving the purpose vague.

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 labels the tool as deprecated and names rush_attest as the canonical tool. This gives clear when-not-to-use guidance and a direct alternative, which is exactly what an agent needs to route away from a deprecated alias.

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 no annotations, the description carries the full burden, and it does add useful behavioral context by noting the cache-write requirement for baseline recording and the returned shape {status, findings[], summary}. It does not explain side effects of other allow_* permissions, how thresholds are applied, or what happens in 'record' vs 'check' modes, so it is only partially transparent.

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 front-loaded sentence with no filler, and it packs the core action, a key prerequisite, and the result shape into a compact string. Every clause 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?

Despite having an output schema, this is a highly parameterized tool with 14 inputs and no annotation support. The description leaves too much undefined for correct invocation: operation values, threshold semantics, samples handling, and the meaning of the many allow_* flags are all absent.

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 covers 0% of the 14 parameters with descriptions, so the description needed to compensate. It only clarifies <path> and the allow_cache_write requirement; the remaining 12 parameters (options, operation, samples, threshold_percent, baseline_name, etc.) receive no semantic explanation.

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 action ('Compare performance samples against baseline thresholds') and a target resource (<path>), so an agent can tell this is a benchmarking/regression-checking tool. It does not explicitly differentiate it from related siblings like rush_load or rush_snapshot, but the core behavior is clear.

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 purpose implies when to use it (when performance samples need to be compared to baseline thresholds), and it adds one operational prerequisite: baseline recording requires --allow-cache-write. However, it gives no explicit guidance about when not to use it or which sibling tool might be more appropriate.

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 no annotations, the description carries the burden of explaining behavior; 'calculate' implies a read-only analysis and 'downstream transitive' adds directionality and recursive traversal. However, it does not disclose failure conditions, side effects, or depth semantics, leaving some behavioral uncertainty.

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 front-loaded sentence with no filler: the verb, target, and input context all appear in nine words. Every phrase adds semantic value.

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?

The tool is simple (two parameters) and has an output schema, so the description need not enumerate return values. Still, the agent is left uninformed about how depth affects the blast-radius traversal and whether any prerequisites exist for the changed file, which keeps it below fully complete.

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 0%, so the description must explain both parameters. It clarifies path as 'a changed file' but gives no meaning for 'depth', which is only visible as an integer default of 5. The description therefore fails to fully compensate for the schema's lack of parameter documentation.

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 ('Calculate') with a precise resource ('downstream transitive blast radius for a changed file'), conveying the tool's core function. It is distinct from all sibling tools, none of which claim the same impact-analysis behavior.

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 'for a changed file' supplies a clear usage context: call this when a file has changed and the agent needs to know its transitive downstream impact. It does not name alternative tools or when-not-to-use conditions, but given the unique sibling set, this is not a significant gap.

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 no annotations provided, the description carries the full behavioral burden, and it delivers on the key safety trait: it states the tool is inspect-only and explicitly does not access credentials or remote status. This is genuinely valuable pre-invocation knowledge an agent cannot get elsewhere. It stops short of describing output shape or error/edge behavior, but an output schema exists to cover returns.

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 sentence that front-loads the verb and resource and appends the behavioral constraint. There is zero filler, and the length is appropriate for a one-parameter inspection tool.

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?

The tool has a small surface area (one required param, output schema present), and the description covers purpose, scope, and a key behavioral boundary. Gaps remain: 'path' semantics are undocumented, and no sibling is named for remote-status or credential-requiring cases, but the information needed to invoke the tool is largely 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?

Schema description coverage is 0% and the description never mentions the single 'path' parameter directly. The agent can only infer from the tool purpose that 'path' likely points to the CI workflow configuration, with no clarification of file vs directory, relative vs absolute, or accepted formats. The description does not compensate for the schema's complete lack of documentation.

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 a specific verb and resource ('Inspect local CI workflow configuration') and adds meaningful scope constraints ('without accessing credentials or remote status'). This helps distinguish the tool from remote-status CI tools and credential-touching operations among the large sibling list, though it never names an alternative sibling explicitly.

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 constraint 'without accessing credentials or remote status' implies the tool is for local, offline inspection, which gives the agent a sense of when it applies. However, no alternative tool is named and no explicit when-to-use/when-not-to-use conditions are given; the agent must infer applicability from the negative scope rather than being told.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal that the tool can run CodeQL analysis with --allow-build and can import SARIF reports, but it does not explain side effects such as whether builds are triggered, whether files are written, whether external downloads occur, or what permissions are needed. The many allow_* parameters suggest behaviors that remain unexplained.

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 with no filler and front-loads the two key actions. It is concise and readable, though it sacrifices important detail for brevity.

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?

Given 9 parameters, no annotations, and no schema descriptions, the description is not complete enough for an agent to safely select and invoke this tool. It omits the meaning of most flags, the distinction between import and analysis modes, and the practical implications of running with --allow-build.

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 0%, so the description must compensate for all 9 parameters. It only hints at the allow_build flag and a SARIF report path, but does not clarify how path and report_path relate, nor explain allow_slow, allow_network, allow_browser, allow_download, allow_cache_write, or allow_artifact_write. This is insufficient for a tool with this many security-relevant flags.

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 identifies the resource (CodeQL SARIF/analysis) and two concrete actions: importing a local SARIF report or running analysis with --allow-build. It does not explicitly contrast with sibling tools like rush_security or rush_scan, but the CodeQL-specific focus makes the purpose fairly distinct.

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 two usage modes—import an existing SARIF report or run a fresh analysis with build allowed—which helps an agent understand basic scenarios. However, it gives no explicit when-to-use guidance, prerequisites, or comparison to alternatives, so the agent must infer appropriate conditions.

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?

Without annotations, the description carries the behavioral disclosure burden. It adds a meaningful caveat (dynamic -X importtime requires --allow-slow) and states the return shape, but it does not disclose whether the audit mutates anything, can execute code, or requires special permissions. Most of the allow_* flags in the schema are left unexplained.

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 concise and front-loaded, opening with the action and resource and summarizing the return value in a compact form. However, given the parameter count, the brevity comes at the cost of needed detail, though this is not a structural or verbosity problem.

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?

This is a high-complexity tool with 11 parameters, no annotations, and no schema-level parameter descriptions. The description only covers the high-level purpose, one behavioral caveat, and the output shape. It is not enough for an agent to correctly supply required parameters like 'options' or understand the allow_* flag semantics.

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 0%, so the description must compensate for parameter meaning. It only indirectly explains dynamic and allow_slow, and it leaves the required 'options' parameter completely unspecified along with the other eight parameters. This is a significant gap for a tool with 11 parameters.

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 ('Audit') and clearly identifies the resource ('import overhead and cold-start latency at <path>'), which distinguishes it from broader sibling tools like rush_benchmark or rush_mem_profile. It is not a tautology and gives the agent a concrete sense of the tool's scope.

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 investigating import overhead or cold-start latency—but it does not explicitly name alternatives or state when not to use it. The note about dynamic importtime requiring allow_slow is useful usage guidance but does not address sibling-tool selection.

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 description discloses the key side-effect (no Git history modification), which is valuable given that no annotations are provided. However, it does not cover other behaviors such as error handling, return format, permissions, or the meaning of the various boolean parameters (allow_slow, allow_build, etc.). With no annotations, the description only partially carries the transparency burden.

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, front-loaded sentence that states the core purpose succinctly with no fluff. It is appropriately concise, though it sacrifices detail for brevity, which is why it is not a 5.

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 9 parameters, no annotations, and a non-trivial schema, the description is severely inadequate. It omits parameter semantics, usage context, behavioral details, and return behavior, making it impossible for an agent to invoke the tool correctly without substantial additional information.

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 9 parameters with 0% description coverage, and the tool description provides no explanation of 'path', 'message', or the permission-like boolean flags. The description fails to compensate for the schema gap, leaving an agent unable to correctly populate the parameters without external knowledge.

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 clearly states a specific verb ('Validate') and resource ('Conventional Commit messages'), and explicitly negates side effects ('without modifying Git history'). It distinguishes itself from sibling tools, none of which suggest commit-message validation, so an agent can identify its purpose without 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?

There is no mention of when to use this tool versus alternatives, no context about prerequisites, and no explicit exclusions. The description only states the primary action, leaving the agent to infer that it is meant for validating commit messages, but without any guidance on scenarios where it might not be appropriate or alternatives to consider.

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 no annotations provided, the description must disclose behavior itself. It does so by naming the engines (radon or jscpd) and the skip fallback when engines are missing. Although it does not explicitly state that the operation is read-only, 'measure' plus the 'status='skipped'' behavior imply a non-mutating analysis.

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 tight sentences front-load the core action and then add only essential engine and fallback detail. No wasted words or redundant schema repetition.

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 single-parameter measurement tool, the description covers purpose, engines, and failure behavior. An output schema exists, so return-value documentation is not required from the description. The only missing piece is explicit usage guidance, which is already captured in the usage_guidelines dimension.

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 0%, so the description must clarify the path parameter. It does so minimally by identifying <path> as the target of complexity measurement and implying Python/JS/TS code, but it does not specify whether path should be a file or directory or give any path-formatting rules. The single generic path parameter leaves little ambiguity, but the description could add more value.

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 first clause names a specific action ('Measure'), a resource type ('Python and JS/TS complexity'), and a target ('at <path>'). Among the many rush_* siblings, this is the only one concerned with complexity measurement, so it is clearly differentiated.

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 use when complexity measurement is needed, but it gives no explicit when-to-use or when-not-to-use guidance and does not name alternatives such as rush_review or rush_lint. The engine and fallback sentence is behavioral, not usage direction.

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?

No annotations are provided, so the description carries the behavioral burden. It discloses a key non-mutating trait ('without rewriting') and a meaningful edge case behavior ('missing hadolint returns status=skipped'). It does not describe every possible status or side effect, but it is strong for a simple check-style tool.

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 efficient sentence with no filler. The primary purpose comes first, and the important behavioral edge case is stated in a compact second clause.

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, no-nesting tool with an output schema, the description is largely complete: it states what is checked, that nothing is rewritten, and what happens when hadolint is missing. The main minor gaps are explicit path semantics and comparison with sibling tools, but the tool is simple enough that these are not critical.

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 has only one required path parameter with 0% schema description coverage, so the description must compensate. The description never explicitly ties 'path' to a container file, even though that is inferable from context. This is a noticeable gap at 0% coverage.

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 ('check') and resource ('container files'), and the phrase 'without rewriting' distinguishes it from mutating or fix-oriented tools. Mentioning hadolint makes the checking mechanism concrete and helps separate it from generic linters.

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 checking container files, but it does not explicitly state when to use it versus siblings like rush_lint, rush_scan, or rush_review. The use case is inferable, but no when-not guidance or alternative routing is provided.

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 no annotations, the description carries full responsibility for behavioral disclosure. It mentions 'real-time' implying a live query, but does not clarify whether the operation is read-only, has side effects, requires authentication, or what happens on failure. No details about the output or any limitations are given.

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, front-loaded sentence that conveys the core purpose efficiently. It is appropriately concise with no wasted words, though it could benefit from a bit more context without becoming verbose.

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?

The tool is simple (0 params, output schema present), so the description need not explain return values. However, it lacks any context about what 'token economy' specifically refers to, potential use cases, or any prerequisites. For a tool with such a specific name, more context could help an agent decide if it's the right choice.

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 tool has zero parameters, and schema coverage is 100% (vacuously). Per guidelines, a baseline of 4 is appropriate for 0-param tools since there is nothing to document. The description adds no parameter-specific detail, which is acceptable given there are none.

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 clearly states the tool's purpose: 'Get real-time token economy savings and cost metrics' identifies a specific verb (get) and resource (token economy savings and cost metrics). It is unambiguous and distinct from the many sibling tools, though it does not explicitly differentiate from similar context-related tools like rush_context_retrieve or rush_token_outline.

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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios where this should be preferred, nor any exclusions. The description only states what it does, not when to invoke it.

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?

No annotations are supplied, so the description carries the full burden. 'Check' suggests a read-only inspection, but the description never states that it does not modify the repository, what permissions are needed, or any other behavioral traits. It does not contradict anything, but it omits the safety profile entirely.

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 front-loaded sentence with no filler. It conveys the action and target in ten words. It is short rather than over-specified, so appropriateness is high.

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 tool with an output schema, the description is mostly sufficient. Gaps remain: what counts as a 'mistake' or 'anti-pattern', which repository/history is checked, and when to invoke this tool relative to its siblings. This is adequate but not complete.

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 properties, so there is nothing to document; schema coverage is trivially 100%. No parameter explanation is needed, and the description adds no irrelevant parameter details.

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 action ('Check') and resource ('git revert history'), and identifies the subject as 'past mistakes and anti-patterns.' It doesn't explicitly differentiate from siblings such as rush_context_retrieve or rush_review, but the domain is distinct enough. Vague terms like 'mistakes' and 'anti-patterns' reduce clarity slightly.

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?

No guidance on when to choose this tool over siblings, when it is appropriate, or when not to use it. The description gives no context, exclusions, or alternatives, so an agent must infer usage from the name alone.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a 'strict token budget' and 'graph-pruned context outline', which hints at the tool's behavior, but it does not disclose side effects, whether it writes to cache (despite the allow_cache_write parameter), what happens when the budget is exceeded, or whether the operation is read-only or mutating. The description is too terse to provide meaningful behavioral transparency.

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 short sentence, which is concise, but it is under-specified rather than efficiently informative. It front-loads the core action but omits essential context. It earns a middle score because it is not verbose, but it does not use its brevity to deliver high-value information.

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?

Given the tool has 4 parameters, no output schema, no annotations, and 0% schema description coverage, the description is far from complete. An agent cannot determine what inputs are required, what the output looks like, or what side effects may occur. The tool appears to be part of a large family of rush_* tools, and without more context, an agent is likely to misuse it.

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 0%, so the description must compensate for the four parameters, but it only mentions 'token budget' (mapping to budget) and 'context outline' (loosely mapping to path). It does not explain what 'path' refers to, what 'symbol' selects, or what 'allow_cache_write' controls. The description adds minimal meaning beyond the schema and leaves most parameters semantically opaque.

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 'Pack graph-pruned context outline under a strict token budget' names a specific verb ('pack') and resource ('context outline'), and mentions a token budget, which gives a rough sense of the operation. However, it does not explain what 'graph-pruned' means or what the output artifact is, and it does not distinguish this tool from the many sibling context-related tools like rush_context_retrieve, rush_token_outline, or rush_context_gain_stats. The purpose is clear enough at a high level but lacks the specificity needed to differentiate it from 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 description gives no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or exclusions, and it does not reference any sibling tools. An agent would have to infer from the name and description that this is for packing context, but there is no explicit routing information.

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 description discloses that the returned content is uncompressed, but no annotation is present to cover safety/aspects. It does not state whether this is a pure read operation, what happens for an unknown or missing hash, or whether any related state is changed.

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 focused sentence with no filler. The core action and key qualifier are front-loaded, making it easy to scan.

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 annotations, no output schema, and 0% schema parameter coverage, this one-line description leaves important gaps: the meaning of 'path', what a successful response looks like, and expected behavior on errors are all absent. More context is needed for reliable invocation.

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 0%, so the description must explain the parameters. It only hints at 'chunk_hash' via the phrase 'by hash' and says nothing about 'path' or its default value, leaving a required aspect of the tool under-specified.

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 ('Retrieve'), a specific resource ('content from CCR chunk store'), and a lookup key ('hash'), making the tool's purpose clear. It stands apart from sibling tools like rush_context_pack and rush_context_mistakes_check, though it does not explicitly name a distinguishing 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?

The description gives no guidance on when to use this tool versus siblings or when it is appropriate to call it. There is also no mention of prerequisites, such as having a valid hash or needing a particular path context.

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 no annotations, the description carries the behavioral disclosure burden. It does disclose the return shape and the requirement that saving needs explicit cache-write permission, which is genuinely useful. However, it does not explain side effects for restore or the other operation modes, whether operations mutate state, or whether network access is involved.

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 with no filler. The core purpose is stated first, followed by the return shape and the most important permission caveat. Every 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?

This is a high-complexity tool with 24 parameters, nine operation enum values, no annotations, and no parameter descriptions. The description covers only a small fraction of that surface, omitting how operation selects behavior and which parameters apply to which modes. An agent cannot confidently call this tool correctly based on the description alone.

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 0% and there are 24 parameters, so the description must compensate heavily. The only added semantics are the cache-write permission requirement and the mention of save/list/restore modes. This is far too little to make the many parameters meaningful, and the agent still has no guide to how path, files, token_budget, or provider_id relate to operations.

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 clear verb and resource: save, list, or restore a local Rush session checkpoint. However, the operation enum reveals nine distinct modes including context_pack, coordination_check, and provider_resume, none of which are mentioned in the description. This makes the stated purpose materially incomplete and potentially misleading about the tool's actual scope.

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 does not say when to use this tool versus alternatives like rush_context_pack, rush_context_retrieve, or rush_memory. It provides no exclusions, no operation-selection guidance, and no prerequisites beyond the cache-write permission for saving. An agent would be guessing when to invoke this tool instead of a sibling.

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?

No annotations are provided, so the description must disclose behavioral traits. It mentions 'import' and 'run verifications', but does not state potential side effects like building, network access, downloading dependencies, or cache writes, even though many parameters (allow_build, allow_network, allow_download, allow_cache_write) suggest these are possible. The description is silent on what actually happens during execution, leaving the agent without critical safety or side-effect knowledge.

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 extremely concise—a single sentence that front-loads the primary action. It wastes no words and is easy to parse. However, the conciseness comes at the cost of essential details, which is a trade-off that reduces effectiveness overall.

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 13 parameters, no annotations, and no output schema explanation, the description is drastically incomplete. An agent cannot determine how to set up the contract verification, what the required 'path' refers to, how 'options' is structured, or what the return value contains. Every aspect beyond the mention of --allow-slow is left unspecified, making the tool effectively inscrutable for an AI agent.

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 0%, meaning none of the 13 parameters have descriptions in the schema. The description itself only mentions the --allow-slow flag, leaving the other 12 parameters undefined. An agent cannot infer the meaning of options like path, pact_files, provider_url, or allow_browser from the tool description, making it impossible to correctly invoke the tool beyond the simplest case.

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 clearly states the tool's two distinct actions: importing a local Pact report and running local contract verifications with the --allow-slow flag. This is specific enough to distinguish it from siblings like rush_test or rush_lint, which focus on other concerns. However, it does not explicitly name any sibling tool as an alternative, so it doesn't fully separate itself in the broader context.

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: when you have a Pact report or want to verify contracts. But it provides no conditions for when to use this tool versus alternatives, no exclusions, and no prerequisites. With a large sibling list, the lack of routing guidance is a notable gap.

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 no annotations provided, the description carries the full burden of behavioral disclosure. It mentions two modes (import vs. run analysis) and the --allow-slow flag, but doesn't disclose side effects, whether it writes files, requires network/build access, or what the output looks like. The schema shows many allow_* flags (allow_build, allow_network, allow_download, etc.) but the description doesn't explain their behavioral implications.

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 with no wasted words. It front-loads the primary action (import) and mentions the alternative mode. However, it's so terse that it sacrifices necessary detail for brevity.

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 9 parameters, 0% schema description coverage, no annotations, and an output schema, the description is far too thin. It doesn't explain the two modes' relationship, what the allow_* flags do, when to use them, or what the output schema contains. An agent would struggle to invoke this tool correctly without opening the schema and guessing at flag semantics.

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 0%, so the description must compensate for the 9 parameters. It only mentions 'local coverage report' (mapping to path/report_path) and '--allow-slow' (mapping to allow_slow), leaving the other 7 parameters (allow_build, allow_browser, allow_network, allow_download, allow_cache_write, allow_artifact_write) completely unexplained. The description adds minimal meaning beyond the schema's field names.

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 action ('Import a local coverage report or run coverage analysis') and names the resource (coverage), which is clear enough to distinguish it from most siblings. However, it doesn't explicitly differentiate it from other rush_* tools that might also analyze code, and the 'under --allow-slow' phrasing is cryptic without explaining what that flag does.

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 gives no guidance on when to use this tool versus alternatives like rush_test, rush_benchmark, or rush_review. It doesn't state prerequisites, when importing a report is preferred over running analysis, or what the --allow-slow flag implies for usage. The agent is left to infer context from the tool name and schema.

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?

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It implies a read-only diagnostic operation but never explicitly states that it performs no mutations, what kind of report or exit status it produces, or how it handles nondeterminism. The phrase 'Audit... to detect' gives intent but not behavioral detail.

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 with no filler or repetition. Every word earns its place, and the core action and target are front-loaded, making it easy for an agent to parse quickly.

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 tool with an output schema, the description is mostly adequate: it states the subject and purpose clearly. However, without annotations or any usage guidance, and in the face of dozens of sibling rush_* tools, it leaves some ambiguity about when this checker should be invoked and what behavioral guarantees it offers.

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 tool has zero parameters, so there is nothing for the description to explain beyond its already-communicated domain. The baseline of 4 applies here; the description's reference to ORM models and migrations provides all necessary semantic context.

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 ('Audit'), a concrete resource ('ORM models'), and a clear objective ('detect schema drift'), so an agent can understand what this tool does at a glance. It distinguishes itself from generic lint/audit siblings by targeting database schema drift, though it does not explicitly contrast itself with any potential sibling like semantic drift.

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 choose this tool over the many sibling audit/drift tools, nor any stated conditions, prerequisites, or exclusions. The intended use is only implied by the verb 'Audit' and the resource scope, leaving an agent to infer when 'rush_db_drift' is the right call.

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?

No annotations are provided, so the description carries the full behavioral burden. It exceeds a bare purpose statement by disclosing the engine strategy ('Uses vulture or knip') and the edge-case fallback ('missing engines return status='skipped''). It stops short of explicitly confirming the analysis is non-destructive, though the verb 'Find' strongly implies read-only.

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 with zero filler. The first sentence front-loads the purpose and parameter role; the second adds tooling and fallback behavior. Every clause 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 single-parameter tool with an output schema, the description covers purpose, supported languages, engine selection, and the missing-engine fallback. The main gap is the absence of an explicit non-destructive/read-only statement, which matters in a family where analysis tools could conceivably also mutate code.

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 0%, so the description must compensate. It does clarify that <path> is the scan target for dead-code detection, but it leaves path semantics open: file vs. directory, recursion behavior, and how vulture and knip interpret the path differently.

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 ('Find') with a precise resource ('unused Python and JS/TS code') and a location scope ('at <path>'). The language-specific scope distinguishes it from adjacent siblings like rush_dead_asset (unused assets vs. code) and from quality tools like rush_lint or rush_complexity.

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 unused Python or JS/TS code needs to be identified at a given path. However, it gives no explicit when-not conditions or named alternatives, which is a meaningful gap given a sibling list of 80+ tools including the closely related rush_dead_asset.

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 no annotations provided, the description carries the full transparency burden. It explicitly states 'strictly read-only,' discloses the return shape ({status, findings[], summary}), and warns that exporting a manifest requires --allow-artifact-write. This is strong behavioral disclosure, though it does not cover edge cases or failure modes.

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 dense sentences with no filler. The action and scope are front-loaded, read-only safety is placed prominently, and the export caveat is compressed into a single clause. Every part 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?

Given the tool's moderate complexity, the description covers the essential context: what it scans, the read-only guarantee, the return shape, and the artifact-write requirement. An output schema exists to fill in return details, so this is sufficiently complete, though it could add a note on whether path must be a directory or file.

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 0%, so the description must compensate. It references all three parameters indirectly: <path>, export manifest, and --allow-artifact-write, and it explains the relationship between manifest export and write permission. However, it does not clarify expected formats, defaults beyond the schema, or the meaning of null values.

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 a specific verb ('Detect') and a concrete resource ('unreferenced images, fonts, and media assets') scoped to a path. This clearly distinguishes rush_dead_asset from siblings like rush_dead (likely code-focused) and rush_media_opt (optimization-focused).

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 tool's use case is implied clearly: run this when you need to find unreferenced media assets under a path. However, it does not explicitly mention alternatives or state when not to use it, so the agent must infer routing from the name and sibling context.

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?

No annotations are provided, so the description carries the behavioral burden. It discloses the output contract '{status, findings[], summary}', which is useful, but it does not mention side effects, prerequisites, network/local behavior, or whether the tool is purely read-only. 'Diagnose' implies non-mutating, but that is left to inference.

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, front-loaded sentence that states the action, target, and return shape. Every word earns its place; there is no filler or redundancy.

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 one optional parameter and an output schema, the description is nearly complete: it names what is diagnosed and the response envelope. It lacks guidance on when to use it among sibling tools, but the output schema covers return-value details.

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 0%, so the description must compensate, but it only repeats '<path>' as a placeholder. It does not explain what path should point to, how the default '.' behaves, or what kinds of paths are valid beyond the schema's format: 'path'.

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?

Description names a specific verb ('Diagnose'), explicit resources ('environment health, toolchain integrity, and binary resolution'), and a scope ('<path>'). This differentiates it from the many sibling rush_* tools, which focus on linting, testing, benchmarking, or scanning, not environment health.

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 the tool is for diagnosing environment/toolchain/binary issues, but it does not state when to prefer it over related tools such as rush_scan or rush_continuity, and it provides no exclusions or alternative recommendations. Context is present but 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 no annotations provided, the description carries the full burden of behavioral disclosure. It discloses one gate — the run requires allow_browser — but says nothing about side effects of E2E runs (launching a browser, writing files, network usage), what happens if the gate is false, or why the other six allow_* permission flags exist. For a tool built around permission-style flags, this is a significant gap.

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 sentence with zero filler, and the verb and resource are front-loaded. However, 'only with --allow-browser' is terse to the point of possible confusion — an agent could mistake it for a shell flag rather than the JSON parameter allow_browser.

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?

The output schema exists, so return values needn't be explained, but the description is still inadequate for a 9-parameter tool with no annotations and zero parameter documentation. It fails to explain the gating model behind the allow_* flags, the role of path and options, or when to prefer a sibling tool, leaving an agent to guess on most of the input surface.

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 0%, so the description must compensate for the schema's silence. It adds meaning to exactly one of nine parameters (allow_browser, and only in CLI notation), while path, options, and the other six allow_* booleans receive no semantic explanation at all. It does not meet the burden set by a 0%-coverage 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 names a specific verb and resource: 'Run configured E2E tests.' The qualifier 'only with --allow-browser' adds a distinguishing condition. It partially separates this from siblings like rush_test by naming E2E tests explicitly, but it does not fully differentiate it from other test-adjacent tools (rush_snapshot, rush_visual) and the '--allow-browser' phrasing is cryptic.

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 configured E2E tests must be run — and states a precondition (pass --allow-browser). However, it gives no explicit when-not-to-use guidance, no alternative routing such as 'for unit tests use rush_test', and no explanation of what happens when the browser gate is not satisfied.

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?

No annotations are provided, so the description must carry the full behavioral burden. It does disclose a meaningful behavioral requirement: exporting markdown requires --allow-artifact-write, which informs the agent about write permissions. However, it does not clarify whether extraction itself writes anything, what side effects occur, or what the output schema contains beyond the catalog concept.

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 dense sentence that front-loads the primary action and includes a key requirement. The only flaw is the awkward literal '<path>' placeholder and the semicolon structure, which slightly reduce clarity without wasting words.

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?

An output schema exists, so return values are partially covered, but the description is still incomplete for an agent deciding whether and how to invoke this tool. It provides no usage context relative to siblings and leaves path and export_path semantics underspecified. The tool is not adequately self-contained.

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 0%, so the description must compensate. It only indirectly addresses the allow_artifact_write parameter via the export requirement, and it uses a literal '<path>' placeholder without explaining what path should be provided. export_path is completely unexplained.

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 ('Extract') with a clear resource ('Python, TypeScript, and Rust exceptions at <path>') and a concrete output concept (RFC 7807 problem catalog). This clearly differentiates it from the large sibling set of rush_* tools, none of which claim this behavior.

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 gives no guidance on when to use this tool as opposed to any of the many sibling tools. It states its function but does not mention alternatives, exclusions, or preconditions for choosing it.

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 no annotations, the description carries the full burden. It discloses the return shape and the 'strict path confinement' safety behavior. However, it does not clearly state that files will be modified, how force affects that, or the purpose of allow_artifact_write. 'Safely' is vague and doesn't cover side effects or dry-run semantics.

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?

Three short sentences with no waste. The main action is front-loaded, followed by a compact return shape and a key safety constraint. Every sentence contributes essential information.

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?

The tool has 4 optional parameters with 0% schema coverage, so the description needs to explain their roles. It only covers path and the overall purpose, leaving force, dry_run, and allow_artifact_write as unexplained flags. It also lacks usage guidance and side-effect disclosure, making the description insufficient for correct invocation without external knowledge.

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 0%, so the description must explain the parameters. It only mentions <path>, leaving force, dry_run, and allow_artifact_write completely unexplained. The description fails to compensate for the missing schema documentation, forcing the agent to guess at the flags' meanings.

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 action ('auto-remediate') and resource ('formatting and linter issues at <path>'), clearly indicating a fix tool. However, it does not explicitly distinguish from siblings like rush_lint and rush_format, leaving some ambiguity about overlapping functionality.

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?

Usage is implied: use it when you want to automatically fix formatting and linter issues at a path. But there is no explicit when-to-use vs alternatives, no conditions, no prerequisites, and no statement about when not to use it (e.g., when you only want to lint or format without fixing).

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?

No annotations are provided, so the description must carry the burden of disclosing behavioral characteristics. It only states the actions 'import' and 'run analysis'; it does not explain whether the operation writes state, requires an existing report, is read-only, or what slow mode implies beyond its name.

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 with no filler, and the primary action is front-loaded. However, it packs two disjoint operations into one clause and brevity sacrifices necessary detail.

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?

A 9-parameter tool with no annotations and only a one-sentence description leaves an agent unable to understand how to select parameters or anticipate side effects. The output schema may clarify return values, but the behavioral and operational context is far from complete.

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 0% and there are 9 parameters. The description alludes only to allow_slow via --allow-slow and provides no meaning for the required path, report_path, or the many allow_* boolean flags.

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 two concrete operations: importing a local JUnit report and running duplicate test analysis, with the --allow-slow condition attached to the latter. It does not explicitly differentiate it from sibling test-related tools, but the verb+resource framing is reasonably clear.

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?

No guidance is given on when to prefer rush_flaky over rush_test, rush_test_heal, or other testing-related siblings. The only contextual hint is the --allow-slow flag, which signals a mode rather than a usage criterion.

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 no annotations provided, the description carries the full burden, and it does well by explicitly stating 'Always check-only in v0.1' and listing the return shape {status, findings[], summary}. It does not fully disclose failure modes, permissions, or path expectations, but the key non-mutating behavior is clearly surfaced.

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 short and every sentence earns its place: purpose, return shape, engines, and behavioral constraint. It is front-loaded with the action and resource, and the additional details are all relevant and specific.

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 annotations and a simple output shape, the description provides enough to call the tool correctly: what it does, which files it targets, the engines, the return contract, and the check-only behavior. It could mention whether path is a file or directory or expand on the `check` parameter, but these are minor gaps.

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 0%, so the description must compensate. It adds useful semantics for path by specifying supported file types and the placeholder '<path>', and 'check-only' clarifies tool behavior. However, the `check` parameter itself is not explained—its default is false but the description does not say what setting it to true does, leaving part of the parameter surface underdocumented.

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 action ('Format'), resource ('Python/JS/TS files at <path>'), and the engines used, making the tool's purpose unmistakable. It is clearly distinguishable from siblings like rush_lint because it is about formatting, and the check-only note further narrows its scope.

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 gives clear usage context: Python/JS/TS files, specific engines, and that it is check-only in v0.1. It stops short of explicitly naming alternative tools or stating when not to use it, but the file-type and engine details are enough to infer the intended use case.

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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It discloses only that fuzz tests are slow enough to require --allow-slow; it does not mention build requirements, network/browser/download side effects (despite six allow_* flags in the schema), or what importing a report entails.

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 sentence with zero filler, and the two primary operations are front-loaded. It is appropriately compact for what it conveys, though the brevity borders on under-specification rather than pure efficiency.

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 complex 15-parameter tool with two distinct modes and no annotations, this description is incomplete. The output schema reduces the burden of explaining return values, but significant gaps remain: which parameters apply to import versus execution, what each allow_* flag gates, and whether import is a prerequisite for running tests.

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 0%, so the description must compensate for 15 undocumented parameters. It adds meaning only to allow_slow and vaguely frames path within the two modes; the remaining 13 parameters (seed, corpus, harness, max_runs, timeout_seconds, and the permission flags) receive no explanation.

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 two concrete operations with a specific resource: 'Import a local fuzz report' and 'execute local fuzz tests.' This is more specific than average and conveys the dual-mode nature of the tool, even though it does not explicitly differentiate it from siblings like rush_test, rush_pbt, or rush_mutation.

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?

No guidance is given on when to use this tool versus alternatives such as rush_pbt or rush_test, and no exclusions are stated. The only usage signal is 'under --allow-slow,' which hints that execution requires that flag, but this is weak and implicit rather than explicit 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It conveys that the tool compares imports against installed packages and the standard library, but it does not state whether the tool modifies files, how it resolves the environment, or what it does with missing or unknown imports.

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 front-loaded sentence with no filler or redundancy. It is appropriately concise for the tool's simplicity.

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?

The output schema likely covers return values, so those need not be described. However, the description omits important invocation context such as path semantics, whether scanning is recursive, and what counts as an 'installed package,' leaving an agent to guess.

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 only parameter, 'path', has no schema description and the description does not explain how path is used or what it should point to (file vs directory). Since schema description coverage is 0%, the description should compensate, but it does not.

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 ('Audit'), a specific resource ('code imports'), and the comparison target ('installed packages and stdlib'). This clearly distinguishes the tool from siblings like rush_lint, rush_security, and rush_dead, whose purposes are not about import validation.

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 gives no explicit guidance on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. An agent must infer the use case from the tool name and one-line description.

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?

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: 'missing local engines return status=skipped'. However, it does not explain what 'local engines' are, whether the operation is read-only beyond the implied 'without rewriting', or any permission/error specifics. It offers some transparency but is incomplete.

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 is concise and front-loaded with the primary purpose. It includes a key behavioral detail (status='skipped') without unnecessary fluff. Every word 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?

Given the tool has only one parameter and an output schema, the description is still insufficient. It does not explain what 'check' entails (validation, formatting, plan? ), what 'missing local engines' means, or what the path parameter should contain. The output schema may cover return values, but the input semantics and operational context are under-specified. For a simple tool with many siblings, more context is needed.

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 description does not mention the sole 'path' parameter at all. The schema only provides the name and format 'path', with 0% description coverage. An agent receives no guidance on what the path should point to (e.g., a directory, a file, a module) or how it relates to the Terraform check. This is a critical gap.

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 clearly states the action 'Check' and the resource 'Terraform', and adds 'without rewriting' to signal it is non-modifying. This distinguishes it from sibling check tools like rush_lint or rush_typecheck by focusing on Terraform specifically. The purpose is unambiguous.

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 context (when you want to check Terraform without rewriting) but provides no explicit when-not-to-use guidance or named alternatives. It does not mention any sibling tools or conditions that would select this over others, so usage is inferred rather than 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?

No annotations are provided, so the description carries the full burden. It states that the tool audits and synthesizes policies and returns a specific shape, but it does not disclose side effects such as writing an output policy file, whether it is read-only, or whether it requires network/sandbox permissions (despite many allow_* parameters). The return shape is helpful but insufficient for behavioral transparency.

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 with no fluff, and the main purpose is front-loaded before the return shape. It is efficient, though slightly under-specified for the tool's complexity; still, for what it contains, the structure is tight.

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?

Given 9 parameters, zero parameter documentation, no usage guidance, and no annotations, the description is incomplete. It does state the return shape, but doesn't explain parameter semantics, invocation context, or side effects. An agent would need to guess how to correctly call this tool for a meaningful audit.

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 0% and the description does not explain any of the 9 parameters. It doesn't mention that 'path' is required, what 'output_policy_file' controls, or what the 'allow_*' booleans mean. The description adds no meaning beyond the raw schema titles.

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 specific actions (audit cloud SDK calls, inspect Terraform HCL2 for wildcards, synthesize least-privilege IAM policies) and a clear resource domain (IAM). This is detailed enough that an agent can distinguish it from generic siblings like rush_security or rush_iac without opening the schema.

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 gives no guidance on when to choose this tool over alternatives, no prerequisites, and no exclusions. It merely states the purpose; the agent must infer when it is appropriate. There is no reference to sibling tools or contexts where this tool is or isn't preferred.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It mentions the operation and return shape, but does not explain important behavioral traits signaled by the parameters, such as whether this audit can be slow, trigger builds, use the network, or write caches. The allow_* flags in the schema remain unexplained.

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 only two sentences long and both earn their place: the first states the core purposeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, and the second gives the return structure. It is front-loaded and free of 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?

Despite an output schema, the tool has 10 parameters with zero schema-level descriptionsy and no annotations, yet the description does not clarify how to invoke it correctly. The presence of allow_slow, allow_build, allow_network, and others implies hidden operational constraints that should be explained, leaving significant gaps for an AI agent.

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 0%, so the description must compensate by explaining parameters, but it does not mention any of the 10 parameters. The meaning of 'path', 'allowed_licenses', 'package_licenses', and the various allow_* flags is left entirely to the schema's field names and defaults, which is insufficient for confident invocation.

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 ('Audit'), a clear resource ('open-source dependencies'), and the exact purpose ('license risks and copyleft compliance'). It does not explicitly distinguish this tool from related sibling tools like rush_security or rush_sbom, so it does not reach a 5.

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 intended use case is reasonably implied: use this tool when an audit of license risks and copyleft compliance is needed. However, the description provides no explicit guidance about when to prefer this tool over alternatives, no exclusions, and no prerequisites, so the guidance remains 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?

No annotations are provided, so the description carries the full burden. It discloses the return contract ({status, findings[], summary}), the engine-per-language routing, and the 'skipped' condition. While not exhaustive, this is solid behavioral transparency for a lint operation.

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?

Three concise sentences with no filler. The action and target come first, followed by the return shape and the engine/status details. Every sentence adds distinct value.

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 low-complexity tool with an output schema, the core contract is adequately covered. However, engine_args semantics and whether path should be a file or directory are underspecified, leaving optional behavior unclear.

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 0%, so the description must compensate. It clarifies the path parameter by specifying supported languages and engine selection, but it never explains engine_args, the optional array parameter, leaving its behavior entirely to inference.

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 action ('Lint'), a specific resource ('Python/JS/TS files at <path>'), and engine mapping, which clearly distinguishes it from siblings like rush_format or rush_typecheck. An agent can immediately understand what the tool does.

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: linting supported files at a path with available engines. It also explains the 'skipped' status when an engine is missing, but it does not explicitly contrast this with nearby alternatives or state when not to use it.

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