Skip to main content
Glama

check_done

Am I done? The stop condition for a coding loop. Free — no subscription, no token budget, no rate limit.

Composes what verifAIed already knows about a branch — failing tests plus the coverage of the functions you changed — into a single verdict you can gate on:

  • done (bool): true only when there are no gaps at all. This is the strict signal to stop.

  • status: "done" | "done-with-warnings" | "not-done". done-with-warnings means the only remaining gaps are ones the repo owner marked non-blocking — read this yourself if you want to stop early.

  • scope: "changed-functions" when a default-branch base exists (only added/modified functions are judged), else "all-functions".

  • gaps: each remaining problem with a ref, the id to act on (function_id/test_id), and a next_action pointing at get_baseline_prompt (free) or fix_branch (paid). Gap kinds:

    • failing_test — a test that failed or errored.

    • untested_function / partial_function — a changed function with no coverage, or only some.

    • unexercised_browser — a changed function that no browser reached, in either the browser-coverage or the manual dimension. Only judged once one of them exists.

    • visually_unreviewed — a changed component nobody has looked at. intent_mismatch — somebody looked and it didn't do what the change claimed. Both only judged once the branch has at least one verify_ui verdict.

    • unverified_recorded_test — a recorded test this branch has never run, or whose last run failed. Re-run it with verifaied test run "<feature path>/<name>" — the feature path is optional and may nest. Branch-wide, not diff-scoped. Absent entirely for a repo with no recorded tests.

    • visual_defect — something verifaied audit measured in the rendered page (overflow, contrast, a broken image, a console error), from the most recent audit of the branch. The one kind that is a warning by default, so it routes to done-with-warnings rather than blocking unless the repo owner turned it on. Only judged once the branch has been audited at least once.

    Gaps are ordered so a component's own gaps are immediately followed by its handlers' and render branches'; a sub-unit gap carries parent_ref (the parent's file::Name) so you can group or indent them without parsing refs. The clustering is presentation only — every gap is still individually actionable by its own ref / function_id.

  • not_checked: signals that couldn't be evaluated (e.g. failing tests when no junit.xml was uploaded, or unexercised_browser when functions exist but no browser coverage was uploaded) — surfaced so a green verdict is never silently green.

Pagination: gaps is capped at max_gaps per call (default 50) to stay within tool-result limits — a low-coverage branch can have hundreds. done, status, scope and gaps_total ALWAYS reflect the full gap set, never just the returned page, so a truncated page is never mistaken for a clean branch. When more gaps remain, has_more is true, next_offset is the offset to pass next, and note spells out how to fetch the rest — call again with that offset until has_more is false.

The intended loop: run your tests with coverage (pytest → coverage.json, or vitest run --coverage --coverage.provider=istanbul → coverage/coverage-final.json) → upload_local_coverage → check_done → fix each gap (get_baseline_prompt / fix_branch) → re-upload → repeat until done is true.

repository is the GitHub 'owner/repo' (a repo UUID also works); branch defaults to the repository's default branch. Errors with an actionable message when no analysis exists for the branch yet — upload coverage first.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "repository": "<repository>"
    },
    "name": "check_done"
  }
}

Input Schema

NameRequiredDescriptionDefault
branchNo
offsetNo
max_gapsNo
repositoryYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.9/5.0
Behavior5/5

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

No annotations exist, yet the description discloses cost ("Free — no subscription, no token budget, no rate limit"), the blocking vs non-blocking distinction for visual_defect, conditional evaluation rules (browser/UI gap kinds only judged once coverage or a verify_ui verdict exists), and the not_checked escape hatch so a green verdict is never silently green. Pagination guarantees — that done/status/scope/gaps_total always reflect the full set — are exactly the kind of behavioral caveat an agent cannot infer from structured fields.

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?

Front-loaded with the core question, then structured into verdict fields, gap kinds, and pagination; every section is scannable. It is long, and some gap-kind parentheticals (e.g. the recorded-test feature-path nesting note) go deeper than selection requires, but the bulk of the length is load-bearing rather than padding.

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?

There is no output schema, so the description must define the return shape — done, status, scope, gaps, not_checked, gaps_total, has_more, next_offset, note — and it does so field by field with value semantics. For a four-parameter read tool with conditional gap logic and pagination, nothing an agent needs in order to call it or interpret the response is missing.

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

Parameters5/5

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

Schema coverage is 0%, so the description carries the whole burden — and it does: repository is defined as GitHub 'owner/repo' (or a repo UUID), branch defaults to the default branch, max_gaps is the per-call cap with its default and rationale, and offset is defined operationally as the value returned in next_offset. Every parameter gains meaning beyond its bare type.

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?

"Am I done? The stop condition for a coding loop" states a specific question-and-verdict operation, not a generic check. It is clearly distinguishable from siblings: fix_branch and get_baseline_prompt are named as the gap-resolution tools, and upload_local_coverage is positioned as its prerequisite.

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 intended loop is spelled out step by step (tests with coverage → upload_local_coverage → check_done → fix each gap → re-upload → repeat until done is true). It also states exclusion conditions: errors when no analysis exists for the branch, and tells the agent to upload coverage first.

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

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources