Skip to main content
Glama

Advance a spec-loop feature

phase

Advance a spec-loop feature to the next schema stage only after completion, owner-edit, and hook checks pass; move it back to an earlier stage on owner request with a reason.

Instructions

Move a spec-loop feature to the next phase of the schema, only when the current phase is complete (entry rules of the next phase included), no owner edit is pending and every beforeLeave project hook of spec/spec-loop.json exits 0; or, with to, back to an earlier phase on the owner's decision with a reason. Runs the onEnter project hooks of the phase entered, records the history entry and every hook run.

Input Schema

NameRequiredDescriptionDefault
byYesWho decided the move: owner when the owner asked for it; a backward move requires owner
toNoAn earlier phase to move back to; omit to advance to the next phase
rootYesAbsolute path of the project that holds spec/; required, since project hooks run there
reasonNoWhy the owner moves the feature back; required with to
featureYesspec-loop feature: its id (FEAT-001), its name (maket-http-connector) or its folder

Output Schema

NameRequiredDescriptionDefault
okYes
toYes
fromYes
nextYesWhat the agent does next: every result about a feature carries it; follow it
hooksYesProject hooks run by this call: beforeLeave hooks of the phase left, then onEnter hooks of the phase entered
patchYes
featureYes
missingYes
reasonsYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A4.6/5.0
Behavior5/5

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

Goes well beyond the annotations by disclosing the gating logic (hook exit codes, pending owner edits), the side effects (runs onEnter hooks of the entered phase, records a history entry plus every hook run), and the fact that project hooks execute inside `root`. These are consequential behavioral traits an agent cannot infer from readOnlyHint=false / destructiveHint=false.

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 primary action and only ~60 words, with zero filler. It is, however, a single semicolon-chained sentence packing four nested conditions, which makes it denser to parse than necessary; a short bullet of preconditions would read better.

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?

Output schema exists so return values need not be explained, and the description covers the operation's preconditions, side effects and the backward-move exception. For a non-destructive, non-open-world state-transition tool with 100% schema coverage, nothing an agent needs before invoking it is missing.

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 baseline is 3, but the description adds genuine meaning: it explains the `to`/`reason` pairing and that a backward move requires `by: owner`, i.e. the cross-parameter constraint the schema only hints at per-property. It does not explain `feature` identifier forms or `root` semantics beyond what the schema already says.

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?

States a specific verb and resource ('Move a spec-loop feature to the next phase of the schema') and even names the governing artifact (spec/spec-loop.json). An agent can distinguish this from siblings like status, validate or reconcile because the description defines the phase-transition operation precisely, including the backward-move variant.

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?

Gives explicit preconditions for advancing (current phase complete, entry rules satisfied, no pending owner edit, beforeLeave hooks exit 0) and explicit conditions for the backward variant (use with `to`, requires owner, requires reason). The gap is that it never references sibling tools (e.g. use status to check phase, validate to test readiness), so routing between tools is left implicit.

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