Skip to main content
Glama

Validate Manifest

validate_manifest
Read-only

Validate a manifest's structure and cross-references without building geometry, rejecting malformed contracts before merge_assembly.

Instructions

Validate a manifest WITHOUT building it (the cheap front door, RFC §11.7). Structural + cross-reference checks a JSON shape can't enforce: every component has exactly one of file/manifest/library; a library carries a tool; every instance references a known component; every mate/check references a known instance; a present schema is the known version ("ankusdrive.manifest/1").

manifest: path to the manifest JSON.

Returns {ok, problems, schema, manifest_hash} — ok is True iff problems is empty; manifest_hash fingerprints the contract content (what the lockfile records so a stale contract is detectable). Run this before merge_assembly to reject a malformed contract before any geometry is built.

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": {
      "manifest": "<manifest>"
    },
    "name": "validate_manifest"
  }
}

Input Schema

NameRequiredDescriptionDefault
manifestYes
workspaceNoRun this call in this named workspace

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv0.5.7
    • addedInput schema / properties / workspace
      Added value: +{
      +  "default": "",
      +  "description": "Run this call in this named workspace",
      +  "title": "Workspace",
      +  "type": "string"
      +}
  2. First observed

TDQS

A4.3/5.0
Behavior5/5

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

Annotations already declare readOnlyHint=true and openWorldHint=false, and the description goes well beyond them: it discloses the return shape {ok, problems, schema, manifest_hash}, defines ok precisely (true iff problems is empty), and explains that manifest_hash fingerprints contract content so stale contracts are detectable against the lockfile. It also flags the cost profile ('cheap'). That is exactly the extra context annotations don't carry.

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 differentiator ('WITHOUT building it') and ordered from purpose to checks to returns to sequencing. The enumerated check list is dense but each item adds discriminating information. Slightly long, but no sentence is filler.

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?

With no output schema, the description takes on return-value duty and does so fully (field names plus the semantics of ok and manifest_hash). Combined with the pre-merge_assembly ordering guidance and the RFC reference, an agent has everything needed to call this correctly without reading further.

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 only 50%, so the description must compensate; it does for the required parameter by specifying manifest as 'path to the manifest JSON', which is more useful than the schema's bare string type. The optional workspace parameter is not mentioned in the description but is documented in the schema itself ('Run this call in this named workspace'), so the gap is minor.

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

Purpose4/5

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

States a specific verb and resource (validate a manifest) and adds a sharp scope qualifier: 'WITHOUT building it (the cheap front door)'. The concrete list of checks a plain JSON-schema check can't enforce makes the tool's remit unmistakable. It does not, however, name or distinguish itself from the numerous sibling validators (project_validate, items_validate, feature_validate, component_contract_check), so an agent must infer the boundary.

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

Usage Guidelines4/5

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

'Run this before merge_assembly to reject a malformed contract before any geometry is built' gives explicit ordering and a concrete motivating failure mode. It stops short of stating when NOT to use it or which sibling validator to pick for non-manifest artifacts, but the sequencing guidance is clear.

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

Deploy Server

Other Tools