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 discloses that the tool deletes temporary unpack directories and explains the two deletion modes, but it does not warn about irreversibility, whether deletion is recursive, or the potential risk of `all=true` deleting more than intended.

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, and contains no filler. Every sentence adds meaningful information about what is deleted and how the two parameters control behavior.

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

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

Given that this is a destructive action with no annotations, the description covers the core behavior and parameter semantics but omitsuseful context such as when to use it after unpack/repack, what the output schema reports, and whether deletion is permanent. An output schema exists, so return values need not be described in detail, but usage context and safety caveats would improve completeness.

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: `dir_path` is explained as a single directory, and `all=true` means delete all unpack directories by prefix in temp. This adds meaningful semantics beyond the bare schema properties, though it could clarify the exact prefix matching rules.

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 verb 'Удалить' (delete) and the resource 'временный каталог unpack' (temporary unpack directory), and it distinguishes the two modes: deleting a single directory vs. deleting all unpack directories via `all=true`. It is easy for an agent to understand what the tool does, though it does not explicitly contrast it with 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 per-parameter usage guidance: `dir_path` targets one directory, and `all=true` targets all unpack directories by prefix. However, it does not state when cleanup should be invoked relative to unpack/repack operations, nor does it mention any conditions or alternatives.

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 so thoroughly: it explains content-based line-by-line diffing for structured formats, byte-level change detection for binary formats, and the meaning of full=false. It also discloses the binary=true marker behavior without any contradiction.

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 cover scope, file-type routing, comparison modes, and flag semantics with zero filler. The main purpose is front-loaded, followed by structured technical details.

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 no annotations, the description provides enough behavioral detail for an agent to invoke diff correctly: input requirements, file-category behavior, and the effect of the only optional parameter. The presence of an output schema covers return-value expectations.

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 compensates by explaining the full parameter's behavior explicitly. It identifies dir_a and dir_b as the two unpacked directories, though it does not clarify comparison direction/order semantics, which is a minor 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 states a precise verb and resource: compare two unpacked directories object-by-object. It enumerates the file types and comparison modes, so the tool's role is unmistakable and clearly distinguished from sibling tools like unpack/repack.

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

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

The description makes clear this tool operates on two unpacked directories (the result of unpack), giving strong context for when to call it. It does not explicitly name alternatives or exclusions, but the usage context is unambiguous enough for agent 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?

With no annotations, the description carries the transparency burden, and it states that the operation is read-only and defines the two output modes: writing to output_path or returning XML in the xml field. It does not cover error behavior or permission requirements, but the main side-effect profile 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?

Two short sentences: the first establishes the primary action and format, the second covers the conditional output behavior. 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?

Despite clear purpose and a useful output-mode note, the description is incomplete for a four-parameter tool with zero schema descriptions. The required dir_path parameter and the object_path/template_name parameters remain undefined, so the agent lacks enough information to call the tool reliably.

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 text must explain the parameters. It only clarifies output_path; the required dir_path and the optional object_path and template_name are left with only their generic titles. An agent cannot confidently construct a valid invocation without extra 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 and resource: export the entire SCD layout to XML in the standard platform format. The word 'целиком' and the explicit format make the tool's scope clear and help distinguish it from related read/import 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 prefer this tool over siblings such as read_dcs, import_dcs, or read_template, and no exclusions or alternative conditions. The only secondary sentence explains output_path behavior, which is parameter semantics rather than use-case 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 behavioral burden. It discloses that mode='check' only verifies help existence while mode='get' returns HTML text and languages, and explains object_path semantics. It does not cover error conditions or permissions, but the read-only nature is implied well enough for this 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 dense sentence with no filler. It front-loads the core action, then efficiently covers mode semantics and object_path rules. Every clause contributes useful 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 output schema exists and the tool is relatively simple, the description covers the key behavioral distinctions and path rules. The main gap is not explaining dir_path in detail or mentioning relationship to sibling tools, but the essential calling context is present.

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

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

Schema description coverage is 0%, so the description must compensate. It explains mode values and object_path rules well, but the required dir_path parameter is not explicitly described beyond the overall catalog context. This is meaningful partial compensation, not complete.

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 verb ('read') and resource ('help info of an object from the raw layer of the unpack catalog'). It is distinct from set_help by orientation, but it does not explicitly compare itself to sibling tools, so it falls just short of full 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 clear usage context for the mode parameter ('check' vs 'get') and for object_path (empty for external processing/reports, 'Type/Name' for config/extension). It does not explicitly mention when not to use this tool or name alternatives like set_help, so no exclusions are 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly explains that output changes depending on object_path and detail, and it lists the kinds of metadata returned. It does not explicitly state read-only behavior or error conditions for missing/unpacked directories, but the core behavior is competently 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 compact and front-loaded: it states the resource first, then gives two conditional behaviors and a modifier. Every sentence contributes useful information, with 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?

Given the tool's moderate complexity, the presence of an output schema, and the detailed parameter explanations, the description is complete for selecting and invoking the tool. An agent knows what to expect for each combination of object_path and detail without needing to open the schema.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains object_path with a concrete format ('Тип/Имя'), explains the effect of detail=true, and the required dir_path is naturally tied to the 'unpacked catalog' resource. Every parameter gains meaning beyond the raw 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 tool returns metadata for an unpacked catalog and distinguishes the two main use cases: a summary when object_path is absent and per-object metadata when it is provided. This makes it easy for an agent to understand what resource and operation the tool targets, and to separate it from siblings like list_objects or read_module.

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 guidance: use with object_path for a specific object, without it for a summary, and with detail=true for a full type-by-type list. It does not explicitly mention when not to use this tool or name alternatives, so it is one step below fully explicit usage routing.

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 burden of explaining what the tool does. It discloses the returned structural elements in good detail, but does not mention behavior such as whether it is read-only, how it filters or traverses the directory, or how it handles missing objects.

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 information-dense, listing concrete output elements and parameter meanings without fluff. It is slightly run-on, but every part contributes to understanding 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?

The description covers the tool's output shape and two of three parameters, and an output schema exists to further clarify return values. However, it omits the meaning of the required dir_path parameter and provides no usage context relative to sibling tools.

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 explains object_path and module_name, but the only required parameter, dir_path, is not explained at all. This is a significant gap for the required input.

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's purpose: it returns the structural decomposition of a BSL module, including variables, procedures/functions, and the main program section. It is detailed enough to distinguish this from sibling tools like read_module or search_code, though it lacks an explicit verb such as 'returns' or 'gets'.

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 alternatives like read_module, search_code, or get_metadata. The content implies structural introspection, but the description does not state conditions or exclusions.

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 burden. It does disclose the side effect (writes to raw layer) and the downstream repack step, which is useful. However, it omits overwrite behavior, idempotence, validation behavior, error handling, or any access/permission 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 compact and front-loaded: it opens with the main action, then specifies the two source formats, then states the target layer and downstream step. Every sentence contributes information without repetition or filler.

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

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

The tool has 5 parameters, no annotations, and 0% schema coverage, so the description needs to be far more complete. It fails to explain the required dir_path parameter, the roles of object_path and template_name, or any edge-case behavior. The output schema may cover return values, but the calling contract is still incomplete.

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 partially does so. It clarifies that template_path is a file and xml_text is a string, but it completely ignores the required dir_path parameter and provides no meaning for object_path or template_name. The one required parameter is left undocumented.

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 action: loading an entire ACS layout (СКД макета) from XML in the standard platform format. It is unambiguous about the resource and source format, though it does not explicitly differentiate from sibling tools like import_template or read_dcs.

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 useful pipeline context by noting that writing goes to the raw layer and assembly is performed by repack, implying this tool is the raw-import step. However, it does not explicitly say when to use this tool versus alternatives such as import_template or read_dcs, nor does it 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 must disclose behavior itself. It does: replacement of existing template content, writing to raw layer, and the need for repack. Missing details like error behavior or reversibility, but the key mutation and layering semantics are stated.

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 compact sentences with no fluff. The primary action and the critical follow-up (repack) are both present and 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?

For a four-parameter tool with no annotations and 0% schema coverage, the description is insufficient for correct invocation: required dir_path is unexplained, and the roles of object_path and template_path are unclear. An output schema exists, so return values need no description, but input semantics are incomplete.

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 needs to explain parameters. It only hints at template_name ('template_name or the only one') and the .mxl input concept; dir_path, object_path, and template_path remain undefined. An agent cannot reliably map all inputs.

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 (import) and resource (object template), with file format (.mxl) and semantics (replaces contents of an existing template). This clearly differentiates it from siblings like read_template (reading), import_dcs (different format), and repack (assembly).

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?

Explicitly says the tool writes to the raw layer and that repack performs assembly, effectively instructing the agent to run repack afterward. It does not explicitly list exclusions vs alternatives, but the raw-layer/repack framing provides clear usage 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 full behavioral burden and does well: it discloses status semantics, field availability per status, and that repeated polling is expected. The polling instruction inherently communicates that the operation is safe and side-effect-free.

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 dense sentence conveys the tool's purpose, response fields, and polling behavior without redundancy. The semicolon-separated field list is compact and the polling instruction is placed at the end.

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 status-check tool, the description fully covers response fields, status semantics, and the polling loop. The output schema exists, so return values need no further explanation.

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 explicitly document job_id; it only implies it is the identifier of the background job created by unpack_async/repack_async. This is inferable but not fully spelled out, and the description does not mention how the ID is obtained.

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 status query for background jobs from unpack_async/repack_async, listing the possible status values and response fields. This verb+resource combination makes it distinct from the 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?

It explicitly instructs polling until status != 'done', providing the core usage pattern, and scopes the tool to unpack_async/repack_async background jobs. It does not explicitly name alternatives or exclusions, but the context is clear enough for correct use.

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 does disclose the output shape and that only names are returned, but it does not explicitly mention read-only behavior, failure modes for nonexistent paths, or whether listing is recursive/top-level. The name implies a read operation, but the description itself adds limited behavioral context beyond the result format.

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 that leads with the main result, states the output format, and adds the alternative tool. There is no redundant wording or filler.

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

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

Given a single parameter and the presence of an output schema, the description is mostly complete. It covers result shape and the closest alternative. It could be more complete by explicitly stating the prerequisite of a successful unpack and a more exact definition of dir_path, but these are minor for this simple listing 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 coverage for dir_path is 0%, so the description must compensate. It provides some context by tying the listing to an unpacked container, which suggests dir_path points to that container. However, it never explicitly names or defines dir_path, leaving the exact path semantics somewhat inferred.

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 operation: list objects inside an unpacked container, and specifies the returned shape ({object_type: [names]}). It also distinguishes itself from get_metadata by explicitly noting that only names are returned while full metadata is handled by that 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?

It gives clear context (operates on an unpacked container) and an explicit boundary: use this for names only, and use get_metadata for full metadata. This is sufficient to route an agent between this tool and its closest 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?

With no annotations provided, the description carries the full behavioral burden. It communicates that this is a parsing/read operation from a specific directory and names the output categories, but it does not explicitly state that the operation is non-mutating, what happens if the module is not closed or unpacked, or any permission/error 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 one tightly packed sentence with no filler. It front-loads the purpose, then adds useful parenthetical detail about what the bytecode parsing yields. It is concise without sacrificing 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 output schema exists, so return-value documentation is already covered. However, the description leaves the object_path parameter unexplained and provides no usage boundary against sibling tools. For a low-complexity read operation this is mostly adequate, but the missing parameter semantics and usage guidance keep it from being 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 compensate for missing parameter documentation. It gives context for dir_path by mentioning the unpack directory, but it says nothing about object_path, which is optional and defaults to empty. An agent cannot infer whether object_path selects a module within the directory or is a path inside the bytecode bundle.

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 'Разобрать' (parse), names the resource (bytecode of a closed module), and specifies the source (raw layer of the unpack directory). It also enumerates the content of the parse result (methods, constants, opcode stream), which clearly distinguishes it from sibling tools like read_module or get_module_structure.

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 explicit guidance is given about when to choose this tool over siblings such as read_module, list_objects, or get_module_structure. The phrase 'from raw-layer of unpack directory' implies a prior unpack step, but there is no direct 'use this when...' statement or exclusion of alternatives.

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 explicitly states the operation is read-only and describes exactly what each mode returns: overview, query with fields, or raw variant XML as stored in .bin. This is strong transparency, though it does not address error behavior 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 compact and front-loaded: purpose first, then mode-specific behavior. Every sentence adds useful information, and the use of semicolons keeps the three modes scannable without unnecessary prose.

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 provides good operational detail for the main read modes and an output schema exists to cover return shapes. However, the required parameter dir_path and two additional schema properties are left unexplained, and there is no guidance for choosing this tool among siblings, creating noticeable 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 explain all parameters. It covers data_set and variant well, but does not explain the required dir_path parameter nor the additional object_path/template_name parameters that appear in the schema. This leaves significant parameter semantics undocumented.

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 reads a data composition scheme (DCS) of a layout, and enumerates the three modes of operation. It does not explicitly distinguish itself from sibling tools such as read_template or export_dcs, so it misses the sibling-differentiation criterion for 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 implies the tool is for read-only inspection and explains how data_set and variant influence the result. However, it does not say when to choose this tool over alternatives or mention any exclusions, so the guidance is implied 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?

With no annotations, the description carries the behavioral burden and does well: it discloses that ranges are 1-based, limited to 400 lines per batch, and that empty module_name/ranges have specific default meanings. It does not mention error behavior or permissions, but for a read operation this is acceptable.

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 leads with purpose, then packs parameter semantics into semicolon-separated clauses. Every part earns its place and nothing is 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?

Given the output schema exists, return-value details are not needed. The description covers path formats, defaults, and range constraints. The only notable omission is an explicit dir_path definition, but the tool name and 'from unpacked catalog' provide enough context for an agent to infer 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 explain the parameters. It does explain object_path, module_name, and ranges with syntax and defaults, but it never explicitly names or defines the required dir_path parameter, only implying it through 'из распакованного каталога'. This is a meaningful 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: 'Прочитать BSL-модуль объекта из распакованного каталога'. This clearly identifies what the tool does and distinguishes it from siblings like read_bytecode and get_модуль_structure.

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 clear context for when to use the tool (read a BSL module from an unpacked catalog) and provides concrete parameter conventions. It does not name sibling alternatives or exclusions, so it misses the top score.

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 states 'only read' and describes the output format (structure + strings), which is good. However, it doesn't disclose details like whether it follows references, handles large files, or any error behavior. The 'read only' tag adds safety context.

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 with the main action ('read tabular document'), then provides output details. It's part Russian, part English, which slightly reduces clarity, but it's appropriately sized and not bloated.

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 reads a template and returns structure+strings, but given no annotations and no parameter descriptions, an agent might not know how to fill object_path or template_name correctly. Since only dir_path is required, that's a clue, but still, the description gives no prerequisites or examples. It's adequate but with clear 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%—the schema gives only field names, types, and defaults, no descriptions. The description does not explain the parameters at all. With 0% coverage, the description should compensate but doesn't, so the baseline 3 for high coverage doesn't apply; however, the needed parameter info is absent, so 3 is appropriate as a neutral score.

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 explicitly states it reads a tabular document (MXL) of a template into structured form, decodes MOXCEL into a tree, and returns canonical text structure and list of string values. This is a specific verb+resource and clearly distinguishes it as a read operation.

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—it's a read-only decode operation returning structure and strings—but does not explicitly mention alternatives or when to use it vs other tools. Since sibling names aren't provided, there's no way to give exclusions, but it still lacks explicit 'when to use' guidance.

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

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

No annotations are provided, so the description carries the full burden. It states the basic operation (create a file from a directory) but does not disclose whether the output file is overwritten, whether the operation is blocking, what happens on invalid input, or any side effects. For a write-like operation, 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?

One dense sentence holds all essential information: the action, source, destination, and the dependency on unpack. No filler words, no redundant restatement of the tool name, and the key relationship is placed early.

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 an output schema present, return values need no explanation. The two parameters are semantically covered, and the unpack dependency is stated. However, for a tool that likely creates files, the absence of behavior notes (overwrite, async/sync, error conditions) makes it only minimally 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 compensate. It maps dir_path to 'unpacked catalog' and output_path to 'target file', giving both parameters concrete meaning that the bare schema lacks. It stops short of explaining path formats or constraints, but the mapping is explicit and useful.

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 ('assemble'), names the resource ('1C file'), and states the source ('unpacked directory') and destination ('target file'). It also explicitly ties the input to the 'unpack' result, which distinguishes it from the other tools in the sibling list.

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 'result of unpack' clearly implies this tool is used after unpacking, giving workflow context. However, it does not explicitly mention alternatives such as repack_async, nor does it state when to prefer the synchronous over the asynchronous variant.

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 disclosure burden. It discloses the key behaviors: execution in a background job, immediate return of `{job_id, status:'running'}`, and result retrieval via `job_status` with `status='done'`. It does not cover error conditions or side effects, but the core async contract is clearly exposed.

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 compact sentences deliver the purpose, the async behavior, the immediate response shape, and the follow-up retrieval mechanism. Every sentence earns its place, and the key behavioral constraint 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?

For a simple two-parameter async tool with no output schema and no annotations, the description covers the essential invocation flow: input directory, target output, immediate job id, and polling via `job_status`. It omits failure modes and edge cases, but is largely sufficient 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?

The schema has 0% description coverage, so the description must compensate. It adds context by mapping `dir_path` to the unpacked directory and implying `output_path` is the target 1C file, but it does not specify path formats, constraints, or whether these should be file or directory paths.

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 specific operation ('сборка файла 1С из распакованного каталога') and the asynchronous execution model, distinguishing it from a synchronous repack tool. However, it does not explicitly name the sibling `repack` as the alternative, so it stops short of full 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 implies usage for asynchronous repack and explicitly instructs the agent to retrieve the result via `job_status`, which is helpful. It does not state when to use this async variant versus the synchronous `repack`, nor when not to use it, leaving the selection guidance 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully reveals that each match contains a layer field and explains scope behavior for SKD, but it does not mention side effects, required prior unpacking, max_results truncation, or error 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 descripion is compact: three short, information-dense sentences, front-loaded with the primary purpose. It avoids fluff, though the telegraphic parameter notes could be slightly better structured for readability.

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 7-parameter tool with no annotations, the description adequately covers the central search semantics and the most nuanced parameters, but leaves gaps around result limiting, case sensitivity, and regex selection. The presence of an output schema reduces the need to document return values, so the overall completeness is acceptable but not thorough.

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 a good job explaining the most complex parameters (layers values and empty=all; scope with query/all), while other parameters like pattern, dir_path, max_results, and case_sensitive are reasonably inferable from their names and defaults. The regex toggle is implied by 'подстроки/regex' but not explicitly mapped to the regex parameter.

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 ('Поиск подстроки/regex') applied to a concrete resource ('текстовым слоям распакованного каталога'). This clearly distinguishes search_code from sibling read/list tools, since it scans across text layers and returns matches tagged with the layer.

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 clear context for when the tool is relevant—searching substring/regex patterns across unpacked catalog text layers—and gives parameter-level usage notes for layers and scope. However, it never explicitly states when to prefer this tool over alternatives like read_module or list_objects, nor does it mention 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?

With no annotations, the description carries the disclosure burden. It explains that the write goes to the raw layer, that repack performs the build, and that overwrite=false preserves existing help. It does not mention permissions or return values, but the main side effects and the overwrite semantics are 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 compact and front-loaded with the operative behavior. Every clause adds information: what is written, where it is written, who builds, and how the two key parameters behave. 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 covers the main behavior, the repack relationship, and the two non-obvious parameter semantics. Since an output schema exists, return-value details are not required here. The only minor gap is the lack of explicit definitions for dir_path and help_html, but both are inferable from context.

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 no parameter descriptions, so the description must compensate. It explicitly explains object_path (empty vs 'Type/Name') and overwrite (false means don't overwrite). However, the required dir_path is only implied by 'каталог unpack' and help_html is not directly described, leaving partial 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 clearly states the verb ('Записать' = write), the resource ('справочную информацию (help) объекта'), and the target ('raw-слой каталога unpack'). It also distinguishes itself from repack by noting that repack performs the build.

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 concrete usage context: object_path is empty for external processing/reports and 'Type/Name' for configuration/extension, and it notes that repack does the build. There is no explicit when-not-to-use or named alternative, but the context is enough to guide invocation.

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 explains that unpacking is complete, has no size limits, handles any objects, writes to a separate temporary directory, and returns a path with both an organized tree and a raw .v8unpack_raw layer. It does not cover temporary directory cleanup or lifecycle, but it discloses the key side effects and output structure.

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, information-dense sentence with no filler. Every clause contributes: the operation, supported formats, scope, temporary location, workflow position, and return value. It is front-loaded with the core 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 description is sufficient for invoking the tool correctly: it identifies the input file types, what the unpack does, and what it returns. The presence of an output schema covers further return details, and the workflow hint links it to the tool family. A minor gap is the lack of explicit guidance on how the returned temporary directory interacts with the cleanup 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%, so the description must compensate for the file_path parameter. It does so by specifying the supported 1C file extensions and clarifying that the parameter refers to a file to be fully unpacked. For a single simple path parameter, this adds meaningful context beyond the bare 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 states a specific verb ('распаковка'), resource ('файла 1С'), and supported file extensions (.cf/.cfe/.epf/.erf), making the tool's function immediately clear. It also distinguishes itself from repack and other siblings by positioning itself as the first step in any cycle and by describing its full unpacking 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 'Первый шаг любого цикла' gives clear workflow context: this tool should be used before other operations on 1C files. It does not explicitly mention alternatives such as unpack_async or cleanup, but it implies the normal sequence well enough for an agent to make a reasonable choice.

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 clearly discloses background-job execution, immediate {job_id, status:'running'} return, timeout avoidance, and the polling contract—exactly the behavioral traits an agent needs.

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 sentences, front-loaded with the async nature and immediate return behavior, then giving polling instructions. Every sentence earns its place without repetition or fluff.

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

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

For a single-parameter tool with an output schema existing, the description covers the complete invocation cycle: start the job, receive as job handle, poll with job_status, and receive the same result as unpack. No essential guidance is missing.

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

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

The only parameter is file_path and the schema has 0% description coverage. The description compensates only indirectly by referring to 'unpacking a large 1C file'; it does not explicitly define file_path, path format, or constraints. The parameter name is self-explanatory enough to prevent confusion, but no extra semantics are added.

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 ('unpack'), the resource ('large 1C file'), and the asynchronous behavior that distinguishes it from the sync sibling 'unpack'. The immediate-return job semantics make the tool's function unmistakable.

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?

Explicitly says to poll via job_status until status!='done' and notes the result will match 'unpack'. This gives the agent a clear usage path and an implicit alternative (use sync unpack when file is small or timeout is not a concern).

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