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 discloses the return fields (output, exit_code, timed_out, duration_ms, truncated), that timeout_ms kills the command, and that max_chars can truncate output. It does not discuss permissions, side effects of arbitrary command execution, or whether partial output survives a timeout kill.

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?

Front-loads the one-shot semantics before the routing advice, then uses compact Args/Returns lists with no filler. The Returns line is terse (bare field names) but earns its place since no output schema exists.

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 six-parameter, unannotated, output-schema-less command runner this covers purpose, routing, all parameters, and the return shape. Remaining gaps are edge cases: partial-output behavior on timeout and environment merge 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 coverage is 0%, so the description must compensate, and it does: it names all six parameters, states cwd defaults to the server's directory, and supplies the shell enum values ('powershell', 'pwsh', 'cmd') that the schema omits. It stops short of details like whether env is merged with or replaces the inherited environment.

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 ('Run a one-shot command to completion') plus the return artifacts, and explicitly separates itself from the persistent-shell siblings. An agent can choose between terminal_exec and terminal_start/terminal_send without opening any 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?

'Use this for non-interactive commands. Use terminal_start + terminal_send for programs that need input, a TUI, or a persistent shell' gives both the when and the when-not with named alternatives. Nothing about routing is left to inference.

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 discloses the Ctrl+C-first sequence, the Windows pseudo-console limitation, the grace-period cascade termination of children, and that the shell is preserved. It stops short of covering failure modes (e.g. no process running) or any permission requirements.

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?

Front-loaded with the one-line purpose, followed by the mechanism paragraph and clean Args/Returns sections. Every sentence adds operational information; nothing is restated from the schema.

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 the Returns section compensates by listing session_id, sent, running and terminated pids. Combined with the behavioral paragraph and parameter notes, an agent has enough to call it correctly, though the terminal_stop relationship and no-op/error case are left implicit.

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%, so the description must compensate, and it documents both parameters: session_id is tied to its producer ('Session returned by terminal_start') and force is explained as skipping the grace period for immediate termination. That is complete for a two-parameter tool.

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 ('Stop the command running in a session') and immediately scopes it with 'keeping the shell alive', which is precisely what separates it from terminal_stop. An agent can pick between interrupt and stop without opening either 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 opening clause gives clear context for when to reach for this tool (kill the running command, preserve the interactive shell) and the force arg note indicates the escalation path. It never names terminal_stop explicitly or states what happens when no command is running, so the exclusion is implied rather than spelled out.

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 exist, so the description carries the full burden. It does usefully disclose the returned attributes (state, pid, cwd, size, idle time, buffer size), which implies a read-only introspection call, but it says nothing about scoping, pagination, or what 'active' means, and doesn't confirm the operation is non-mutating.

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 compact sentence with the verb and resource front-loaded and no filler. The enumerated attribute list is informative rather than padding, though the near-duplicate 'size' and 'buffer size' is slightly redundant.

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

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

With no output schema, the description compensates by naming the fields returned, which is the key missing piece for a listing tool. Remaining gaps are minor: what counts as 'active' and whether sessions from other workspaces are included.

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 takes zero parameters, so there is no parameter meaning to convey and the baseline is 4. The description's field list is about return values, not inputs, so it neither helps nor hurts here.

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 (List) and resource (active sessions), and enumerates the attributes returned. It is clearly distinguishable in substance from siblings like terminal_read or terminal_screen, though it never names or contrasts them 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 description gives no when-to-use guidance, no prerequisites, and no mention of alternatives such as terminal_screen or terminal_read. The agent must infer that this is a discovery/overview call from the verb 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, the description carries the full burden and does well: it discloses incremental/deduplicated semantics, that max_chars returns head+tail with an explicit omission marker, and that dropped/truncated/running/exit_code flags exist. The PSReadLine repaint caveat is genuinely useful behavioral context a schema could not convey.

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

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

Front-loaded core sentence, then an Args/Returns/Note structure that is scannable and every line earns its place. Slightly verbose relative to the simple read operation, but the added detail is functional rather than 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?

Although there is no output schema, the Returns line names the returned fields (text, cursor, dropped, truncated, running, exit_code), and the body explains the cursor resume workflow and the authoritative-view caveat. Nothing an agent needs to invoke this correctly appears to be missing.

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

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

Schema description coverage is 0%, so the description must compensate fully, and it does: every one of the six parameters (session_id, since, max_chars, grep, tail, strip_ansi) is given meaning beyond its name, including precedence ('tail applied after grep') and the head+tail truncation behavior of max_chars.

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 (read incremental raw output) and immediately sharpens it with the scoping constraint 'without duplicates' and 'only what arrived after the previous read'. It also names the distinguishing sibling, terminal_screen, for authoritative views, so an agent can tell it apart from the other terminal 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?

Provides clear operational context: use the returned cursor with `since` to resume, and use terminal_screen rather than raw reads when an authoritative view is needed due to PowerShell repaint. It names the key alternative and its trigger condition, though it doesn't enumerate the remaining siblings (terminal_exec, terminal_wait, etc.).

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?

Since no annotations are provided, the description carries the full behavioral burden. It discloses the tool's effect on the environment (wrapping and full-screen programs) and provides critical operational constraints—the strict minimum and maximum range limits for cols (2..1000) and rows (2..500), which define acceptable input 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 definition is highly efficient. It begins with a clear summary, followed immediately by an easy-to-parse argument list that integrates both semantic meaning and functional constraints without unnecessary padding.

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 definition is exceptionally complete for a tool with no output schema or annotations. It provides the required inputs, the operational constraints for those inputs, and the necessary linkage to the terminal session lifecycle.

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 coverage is noted as 0%, meaning the description must compensate heavily. The description excels by defining the unit (width/height) and providing explicit bounds for both `cols` and `rows`, which is critical semantic and validation information absent from the bare input 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 clearly states the action (Resize) and the resource (pseudo-terminal). It provides specific functional consequences (affects wrapping and full-screen programs), clearly distinguishing its purpose from sibling tools like terminal_start or terminal_exec.

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 provides an essential prerequisite condition by stating that the required session_id must be 'Session returned by terminal_start.' This guides the agent on the correct workflow and dependency, although it does not explicitly 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.

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 discloses VT emulation semantics (cursor moves, erases, color codes applied), the truncation strategy for max_chars (head+tail with an omission marker), and the return shape including running and exit_code state. It does not address whether reading is side-effect-free or how errors surface, but the core behavioral picture is solid.

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?

Front-loaded with the one-line purpose, then Args and Returns blocks that are easy to scan. Every sentence contributes, though the section scaffolding is slightly heavier than strictly necessary.

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?

No output schema exists, but the Returns block enumerates the fields (text, cursor, cols, rows, running, exit_code), and both parameters are documented. For a two-parameter read tool this is nearly complete, with only edge cases like reading a finished session left unaddressed.

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%, so the description must compensate, and it does: session_id is tied to 'Session returned by terminal_start', and max_chars is explained as a head+tail truncation with an omission marker, which is meaningful behavior beyond the bare schema default.

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 ('Return the rendered terminal screen (VT emulation) with cursor position') and the phrase 'This is the clean view' implicitly differentiates it from a raw-output sibling like terminal_read. However, it never names terminal_read, so the agent must infer the distinction rather than being routed 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?

Gives clear usage context: use it to see 'exactly what a human would see, including the current prompt or TUI', which tells the agent when a rendered view is preferable to raw bytes. There are no explicit exclusions and no named alternative, so it stops short of a 5.

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 behavioral burden. It usefully discloses that text is not followed by Enter unless enter=true, the full supported key set, and the 1..100 repeat bound, but says nothing about blocking behavior, error handling on a dead session, permissions, or rate limits for a mutation-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?

Front-loaded summary followed by tight Args/Returns sections; every element earns its place. The enumerated key list is long but not present in the schema, so it is justified rather than padding.

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?

No output schema exists, and the description compensates by naming the returned fields (session_id, sent_chars, running state). Combined with the thorough parameter documentation, an agent has enough to invoke it correctly, though side-effect and failure behavior remain unstated.

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, and it largely does: it names the origin of session_id, explains text vs keys, enumerates the valid named keys, and gives the repeat range. Only minor gaps remain, such as how text and keys interact when both are supplied.

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 line gives a precise verb+resource: send text and/or named keys to a session, and the Args section elaborates the two input channels. It does not, however, differentiate itself from siblings like terminal_exec or terminal_interrupt, which an agent must choose between for the same session.

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 only implied by the parameter semantics (type literal text with text, send control sequences with keys). There is no explicit statement of when to prefer this over terminal_exec, nor any prerequisite or exclusion 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, the description carries the full burden. It does disclose the destructive side of replace ('Kill an existing session with the same name') and enumerates the return fields including a 'ready reason', which is genuinely useful. It says nothing about session lifetime/persistence, cleanup responsibilities, or failure behavior, which are significant for a long-lived stateful resource.

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 purpose is front-loaded in one sentence, then cleanly separated into Args and Returns blocks. Nothing is padded and the parameter list is justified because the schema itself provides no descriptions.

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 an 8-parameter, stateful, no-annotation tool with no output schema, the description covers parameters and return shape well. It stops short of telling the agent how this session relates to the other session tools (send/read/stop) or how long the session lives, which is the main remaining 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%, so the description must compensate, and it does: all eight parameters are explained with concrete values ('powershell', 'pwsh', 'cmd', or an absolute path), defaults (120 cols, 30 rows, server cwd), and semantics (env is merged into the inherited environment, name auto-generates as t1/t2, args are extra shell arguments).

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+resource ('Start an interactive terminal session') and the return payload, so the agent knows exactly what the tool does. It does not, however, contrast itself with the closest sibling, terminal_exec, which an agent could reasonably confuse it with for command execution.

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 rather than stated: 'interactive terminal session' versus terminal_exec/terminal_send, and the replace flag's kill-and-restart behavior hint at when to use it. There is no explicit when-to-use/when-not-to-use guidance or named alternative anywhere in the text.

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 disclose a genuine behavioral trait: force kills the whole process tree rather than requesting a graceful stop. However, it omits the consequences of a non-forced close, error behavior for unknown sessions, and whether the call blocks.

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 purpose is front-loaded in one sentence, followed by a compact args block. Nothing is padded, though the args header formatting is slightly heavier than the content warrants.

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 stop tool with no annotations and no output schema, this covers the essentials but leaves gaps: no relationship to terminal_interrupt, no statement of what happens to the session's output or files, and no failure semantics. Adequate but not complete for a destructive operation.

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, and it does: session_id is tied back to terminal_start, and force is explained as graceful-stop vs process-tree-kill. Both parameters gain meaning the schema alone does not provide.

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 gives a specific verb and resource: 'Close a session and free its process.' This is clear and concrete, but it does not explicitly differentiate from siblings like terminal_interrupt, which an agent might reasonably confuse with stopping a session.

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 when-to-use guidance or statement of alternatives. The sibling set contains terminal_interrupt, and an agent gets no help deciding between an interrupt and a full stop. The force note explains a parameter choice, not when to reach for this 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 it does well: it discloses blocking behavior, the four termination reasons, the disabling semantics of quiet_ms=0, and the echo-matching pitfall that ignore_echo exists to avoid. It does not address whether the wait consumes buffered output or how it interacts with concurrent reads, which is the main remaining behavioral 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?

The single-sentence purpose is front-loaded and the Args/Returns blocks are compact. The Args list restates parameter names already visible in the schema, which is mild redundancy, but each line still adds semantics that the schema does not carry.

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?

No output schema exists, so the description proactively documents the return fields (reason, matched, running, exit_code, screen), which is exactly the right compensation. It is nearly complete for a 5-param tool; the missing piece is the relationship to terminal_read/terminal_screen regarding whether waited-for output is consumed.

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 entirely, and it does: all five parameters get meaning, not just names – a regex example for `until`, the 0-disables rule for `quiet_ms`, and the rationale for `ignore_echo`. `session_id` is tied back to terminal_start, which is the only cross-tool linkage the schema lacks.

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 (block/wait) and the exact four conditions under which it returns: regex match, quiet, session exit, or timeout. The blocking semantics immediately separate it from the immediate-read siblings terminal_read and terminal_screen, so an agent can pick it without opening a 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?

It gives one concrete usage rule – 'Provide at least one of `until` or `quiet_ms`' – which is genuinely useful constraint guidance. However, it never says when to choose this tool over terminal_read or terminal_screen, nor when a quiet wait is preferable to a regex wait. Usage is implied rather than stated.

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