Skip to main content
Glama

Read dimensions, tags and notes

annotations
Read-only

Identify stale dimensions and notes that no longer match the drawing, search label text, and verify sizes and anchors after geometry changes.

Instructions

Plan annotations, read. stale=true lists notes whose numbers no longer match the piece they are about, piece names whose sizes (módulo 70 cm, 80 × 60) no longer match the piece, dimensions whose anchor is gone, and unanchored dimensions left with one end in the air a few cm from a face (the drawing moved under them): rows [id, written, measured, against, text]; checked {dims, dims_unanchored, labels, names} counts what was compared — an empty list with nothing checked is not a clean plan — and unverified [[id, text]] lists sizes nothing can confirm: a label about no piece, or a name giving an inner opening, niche, leaf or set (vão, nicho, folha, conjunto) — run it after moving geometry, before handing the plan over. A note says which piece it is about with update(id=t1, about=f5); without that, one standing on a piece or beside a single piece that still shares a number is checked too. q= searches label text on every storey; q=re: by a regex (re:^\[\d+\]$ finds index codes). With neither, returns the schedule {dims,refs,details,legend,rooms:[[room,[[tag,name,w,d,h,brand?,model?,url?]]]]} — the modes on, and the room reference schedule with its tags. edit_annotations turns modes on and off, ties dimensions and bakes chains. Give pieces brand/model/url via update.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
qNoSearch label text, accent- and case-insensitive, e.g. `porta`; or `re:<pattern>` for a regular expression
staleNoDimensions and notes that no longer match the drawing: rows [id, written, measured, against, text]

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
revNoPlan revision
dimsNoDimensions shown
refsNoReference tags shown
roomsNoThe schedule: [room, [[tag, name, w, d, h, brand?, model?, url?]]]
staleNostale=true: [id, written, measured, against, text]
labelsNoWith q: labels {id, text, at, …}
legendNoLegend shown
checkedNostale=true: what was checked
detailsNoDetails shown
unverifiedNostale=true: [id, text] nobody can check

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.6/5.0
Behavior4/5

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds valuable behavioral context: stale=true lists rows with a specific shape, checked counts what was compared, unverified lists sizes nothing can confirm, and the warning that 'an empty list with nothing checked is not a clean plan.' It also discloses the fallback note-checking behavior (a note standing on a piece or beside a single piece that shares a number is checked). This goes beyond the annotations without contradicting them.

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

Conciseness4/5

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

The description is dense but every sentence earns its place: it covers the stale mode, checked counts, unverified lists, the note-checking rule, q= search, the no-args schedule, and the sibling edit_annotations. It is front-loaded with the core purpose ('Plan annotations, read') and then details modes. It is long, but the complexity of the tool justifies the length; no filler or repetition.

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

Completeness5/5

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

For a read-only tool with an output schema, the description is remarkably complete. It explains all three invocation modes (stale, q, no-args), the exact row shapes, the meaning of checked and unverified, the note-checking fallback, and the relationship to edit_annotations. The output schema covers the schedule structure, so the description doesn't need to repeat it. An agent has everything needed to call this tool correctly.

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

Parameters4/5

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds meaning beyond the schema: it explains what stale=true returns (rows [id, written, measured, against, text]) and what q= does ('searches label text on every storey'), plus the regex variant. It also clarifies the no-args mode returns the schedule. This is more than the baseline 3 for full schema coverage.

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

Purpose5/5

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

The description opens with 'Plan annotations, read' and then enumerates exactly what the tool does: lists stale dimensions/notes, checks counts, lists unverified sizes, searches label text, and returns a schedule. This clearly distinguishes it from sibling tools like edit_annotations (which 'turns modes on and off, ties dimensions and bakes chains') and update (which sets piece properties).

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

Usage Guidelines5/5

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

The description gives explicit when-to-use guidance: 'run it after moving geometry, before handing the plan over.' It also explains the modes (stale, q, no-args) and contrasts with edit_annotations, which is the sibling that modifies annotations. The q= and re: syntax is fully specified, so an agent knows exactly when to invoke this read tool versus a write tool.

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