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

With no annotations, the description carries the burden. It reveals a multi-step analytical pipeline and the conditional branching based on bugfix vs feature, plus a 'complete structured result' return. However, it does not disclose whether the operation is read-only, potentially expensive, or what happens when optional params like pr/base/head are absent. These are meaningful gaps.

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 short, dense paragraphs with a front-loaded purpose and no filler; every sentence contributes purpose, pipeline, or routing to siblings. Nothing is wasted.

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 params, no output schema, and no annotations. The description communicates the overall workflow and result shape at a high level, but leaves out how the optional parameters combine, what a 'complete structured result' actually contains in detail, and any constraints or prerequisites. Sufficient as a summary, not as full operational guidance.

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 explains how repo, pr, base, or head are used. The param names are somewhat self-evident in a git context, but the description adds no mapping to its pipeline stages, so it cannot compensate for the lack of schema descriptions.

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 'Full RCA in one call' and maps the internal pipeline (classify -> suspects/blast-radius -> risk score -> test impact), giving a specific verb-resource scope. It clearly differentiates itself from sibling tools by framing them as drill-downs, so an agent can tell this composite tool apart.

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?

It explicitly states when to use this tool ('Full RCA in one call') and when not: 'Use the individual tools to drill into specific signals.' That is an explicit alternative and exclusion, even though it does not enumerate each sibling by name.

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 but does disclose the operation ('find references') and a detailed return shape ('Returns: {symbols: [...], other_call_sites: {...}, untouched_count: int...}'). It does not state side-effects or permissions, though the read-only nature is implicit. This is reasonable transparency for an analysis 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?

Three short, purposeful blocks: a framing question, a one-line action, and a structured return shape. 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?

The output format is fully documented, but the input semantics are absent and there is no guidance on how repo/base/head relate to the fix being checked. With no output schema or annotations, the definition is incomplete for a 3-param tool.

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

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

Schema description coverage is 0% and the description does not explain base, head, or repo. The terms 'changed symbols' and 'this fix' are not mapped to parameter values, so an agent cannot know what to supply.

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: 'Find other references to changed symbols not touched by this fix.' This clearly conveys it checks completeness by locating untouched references, distinguishing it from siblings like verify_fix or get_test_impact.

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?

Implies use when checking whether a fix is complete, but provides no explicit when-to-use, prerequisites, or alternatives. No exclusions or routing to sibling tools.

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

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

With no annotations, the description carries the burden of explaining observable behavior. It does disclose the return shape ('{verdict, evidence, signals}') and the 'unknown' verdict class, which is useful. However, it does not state whether the tool is read-only, what inputs are required semantically, or any failure behavior, so the gap remains non-trivial.

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, front-loaded with the core purpose, and adds a compact return signature. It earns its two sentences without padding, though it is perhaps too sparse to fully serve the 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?

There is no output schema and no annotations, so the description must be more complete to support correct invocation. It gives the return shape and verdict options but omits parameter semantics, usage conditions, and relationship to sibling tools. For a classification tool with three unannotated parameters, this is a clear completeness gap.

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 define the three parameters. 'Base' and 'head' are only inferably commit refs from the 'change' wording, and 'repo' is not described at all. The description entirely fails to compensate for the schema's lack of explanations.

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 ('Classify') and a specific resource ('a change'), and clearly states the output categories (bugfix vs feature) with evidence. It does not explicitly contrast with sibling tools like get_intent or analyze, so it misses the top score for sibling differentiation.

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 a sibling, no prerequisites, and no exclusions. The only implied usage is that it classifies changes, which is weak because several sibling tools also analyze changes.

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 handles it well: it explains the trace-based RCA path, the diff-based path, and the exact return shape. It stops short of explicitly stating side effects or read-only behavior, but this is clearly an analytical/find 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?

The description is compact and front-loaded with the core purpose, followed by usage modes and return structure. Every line earns its place, with 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?

The description is complete enough for a moderate-complexity tool: it names the required repo, the two input modes, and the output shape. It could be stronger by explicitly contrasting with related siblings such as from_trace and by clarifying how base/head behave when omitted.

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 for trace_text, base, and head by explaining the stack-trace flow and the base..head diff flow. The required repo parameter is left implicit and not explicitly described, which is the main 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 opens with a specific verb and resource: 'Find the commits most likely to have introduced a bug.' It also clarifies two distinct modes (trace_text vs diff base..head). It does not explicitly distinguish itself from sibling tools like from_trace, so it falls just short of 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 description gives clear conditional usage: pass trace_text for a stack trace/crash log, otherwise diff base..head. This tells the agent when to use each input path, though it does not name alternatives or explicitly state when not to use the tool.

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 does well: it explains the workflow (parse, blame in git history, return suspect set) and discloses the return shape. It does not mention whether any git history access could require permissions or whether the operation is read-only, but the described behavior is clear and non-destructive.

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

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

The description is compact and front-loaded. The first sentence captures the tool's purpose and key differentiator, the second explains the mechanism, the third lists supported languages, and the fourth gives the return shape. 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?

Given there is no output schema, the description provides a useful return shape and gives a solid overall picture of the tool's behavior. However, the unexplained 'head' parameter and lack of any guidance on how to interpret suspects or skipped frames leave small but real gaps for an 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 for parameter meaning. While 'trace_text' is implied by 'stack trace' and 'repo' is implied by 'git history,' the 'head' parameter is completely unexplained. This is a meaningful gap because head likely controls which git ref is blamed but the description gives no hint.

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+resource: it performs RCA from a stack trace or crash log, parses the trace, blames crashing lines in git history, and returns a suspect set. It also distinguishes itself from diff/PR-based analysis with 'no diff or PR needed,' which separates it from sibling 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 gives clear context for when to use the tool: when you have a stack trace or crash log and no diff or PR is available. It also scopes applicability to Python, JavaScript, Java, and Go traces. It does not explicitly name alternative tools or exclusion conditions, so it misses a full when-not-to-use statement.

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 behavioral transparency burden. It reveals the output shape (dependents, covering_tests, high_risk, notes) and the general analysis scope, which is useful. However, it does not disclose side effects, required permissions, how base/head relate to repository state, or any operational constraints.

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 compact, front-loaded with the main purpose, and uses the return block to convey output structure efficiently. Every sentence earns its place and there is no 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?

With three parameters, no output schema, and no annotations, the description should compensate by explaining the parameters and usage context. It provides the purpose and return keys but leaves base/head semantics, repo interpretation, and sibling differentiation unaddressed, so an agent cannot confidently invoke it beyond a basic repo argument.

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 adds no explanation for base, head, or repo. The parameter names are somewhat self-explanatory, but the description does not clarify that base/head likely represent a comparison range or how repo is used, leaving the agent to guess.

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 ('Map') and resource ('what a feature change affects'), and enumerates the key outputs: dependents, covering tests, and high-risk areas. It is clear enough to distinguish it as blast-radius analysis, though it does not explicitly contrast with sibling tools like get_test_impact or get_risk_score.

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 'Map what a feature change affects' implies this tool is for impact analysis after a feature change, which is a usable but implicit usage signal. It provides no exclusions, prerequisites, or guidance on when to choose this tool over the listed sibling tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals the operation (git log -L), ordering (oldest to newest), and the exact return shape including per-step diffs and notes. It does not mention error cases or the optional base parameter behavior, but for a read-only query the essential behavior is disclosed.

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

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

The description is two sentences, starts with the core git log -L analogy, and provides the return structure without any filler. 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?

The return structure is explicitly documented, which matters since there is no output schema. However, the tool has 5 parameters and 0% schema description coverage, and the description does not explain base, file/repo expectations, or line indexing/inclusivity semantics. This leaves an agent with some guessing about how to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only indirectly covers start_line and end_line via the phrase 'line range'. The repo, file, and base parameters are left entirely unexplained, forcing the agent to infer semantics from parameter names alone.

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

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

States a specific verb and resource: `git log -L` over a line range, returning every commit that touched those lines. This clearly conveys what the tool does and is easily distinguished from sibling tools like get_blast_radius or get_risk_score, which concern impact and risk rather than line history.

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 frames when to use it: when you need the commit history and diffs for a specific line range in a file. It does not explicitly name alternatives or exclusions, but the scope is unambiguous enough to guide selection among the siblings.

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 must carry the transparency burden. It does disclose that pr can be null and shows the return shape, but it does not address side-effect safety, auth/network assumptions, or what happens when the commit is not found. Nothing contradicts the annotations because none were provided.

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

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

The description is two short lines with no fluff and the return type is front-loaded. The first fragment is telegraphic ('Commit body + ...'), but the information density 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 simple two-parameter read tool, the return shape and nullable PR are useful. Still, with no output schema and no annotations, the absence of parameter formats and error/edge-case behavior leaves an agent with meaningful unknowns.

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 undocumented parameters. It does not: repo and commit_hash are never explained, and no format is given (e.g., full SHA vs short SHA, owner/repo form for repo). The parameter names are guessable, but the description adds no parameter-specific meaning.

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 specifies the resource (commit) and the data returned: commit body, originating PR metadata, and linked issues. It is distinct from sibling analysis tools like get_test_impact or get_risk_score, though it omits an explicit verb like 'retrieve' or 'fetch'.

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

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

The description makes the intended use obvious—any agent wanting commit body, PR context, or linked issues—but it never states when not to use it or names an alternative. With siblings like analyze and get_blast_radius around, explicit routing guidance would be valuable.

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 and does a reasonable job: it states the output range, the level vocabulary, the contributing factors, and the exact return shape. It does not discuss side effects, but 'get' plus the output focus makes read-only behavior reasonably inferable. The main omission is how the tool behaves when optional parameters are omitted.

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 compact and well structured: the core purpose and output scale are front-loaded, followed by the combination inputs and then a precise return type. Every sentence adds information, and 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?

The description is thorough about the output and calculation inputs, but it omits the most critical operational context: how to identify the change being scored. It does not explain whether repo+pr is the intended invocation or whether base/head commits define a range. With no annotations and no output schema, these omissions leave the tool underspecified for correct 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 provides no explanation of the parameters: repo, pr, base, or head. It never states that pr is a pull request number, what base/head refer to, or how they relate to the required repo parameter. With no schema descriptions and no compensation in the description, an agent cannot confidently populate the 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 clearly states that this tool produces a QA risk score (0-100) for a change, including a level and contributing factors. It also lists the combined inputs, which makes it distinct from siblings like get_blast_radius or get_test_impact. However, it does not explicitly name an alternative or contrast itself with a sibling.

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 explicit guidance on when to use this tool versus the many siblings such as verify_fix, check_completeness, or classify_change. The phrase 'QA risk score for a change' implies a use case, but the description never states when this aggregate score should be chosen over more specific tools, nor does it mention any exclusions or prerequisites.

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 behavioral burden. It discloses the traversal mechanism, the hop limit, and the return format. It implies a read-only operation consistent with the 'get' prefix, though it does not cover edge cases or prerequisites.

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: three sentences covering purpose, method, and output. There is no redundant or filler content, and the most important information is front-loaded.

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 return structure is documented, which compensates for the missing output schema. However, with no annotations and no parameter explanations, the agent cannot confidently construct a correct invocation, especially for the optional base and head parameters. The description is sufficient for understanding the tool's purpose but not for reliable parameter usage.

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 provides no meaning for the repo, base, or head parameters. The term 'changed files' hints at a diff, but the role of base and head is not explained, leaving the agent to guess how to specify the change.

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 function as selecting existing tests for a change, and adds algorithmic detail about walking the reverse-import graph up to 2 hops. However, it does not differentiate itself from sibling tools such as get_blast_radius or find_suspects, which would elevate it to 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 phrase 'for this change' gives clear context for when the tool should be used. It does not mention explicit alternatives or exclusions, but the intended scenario is reasonably apparent from the opening question.

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 discloses important behavior: the exact return object, the meaning of 'complete', the risk_level caveat, and the need to inspect notes. It does not explicitly mention side effects or auth needs, but the tool reads as an analysis-only check.

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 front-loaded with a one-line purpose and then gives necessary operational detail, including a return schema equivalent. It is slightly dense but every sentence adds value and there is no 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?

The description is strong for an analysis tool: it explains when to invoke it, how to interpret the verdict, what to check before committing, and what the result shape is. The main gap is the undocumented base parameter and the lack of explicit guidance on prepasing proposed_diff beyond calling it a raw unified diff.

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 clarifies proposed_diff as a raw unified diff. The required repo and optional base parameters receive no explanation, and base is never mentioned, leaving the agent to guess its role.

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 and resource: checking fix completeness against a raw unified diff and returning a verdict. It is clear and distinct from a generic 'check', but it does not explicitly contrast itself with the sibling check_completeness tool, so sibling differentiation is incomplete.

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 operational context: use this before committing and iterate until verdict is 'complete'. It also explains what to do for a complete-but-untested fix, but it does not state exclusions or name alternatives among siblings.

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