Skip to main content
Glama

Lifecycle Editable

lifecycle_editable
Read-only

Check if an item is editable before writing by verifying its lifecycle state; returns whether it is in_work (editable) or frozen.

Instructions

The cheap "is this editable?" check a builder runs before writing (#141 C2). An item is editable only in lifecycle state in_work; in_review, released and obsolete are frozen (released = immutable, the API-stability guarantee).

registry: path to the items.json sidecar. item: the item id to check.

Returns {ok, editable, state}.

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": {
      "registry": "<registry>",
      "item": "<item>"
    },
    "name": "lifecycle_editable"
  }
}

Input Schema

NameRequiredDescriptionDefault
itemYes
registryYes
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
Behavior4/5

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds genuine behavioral context the annotations don't: exactly which states are editable vs frozen (in_review, released, obsolete) and the released=immutable stability guarantee, plus the return shape. It doesn't explain the cheap-vs-expensive distinction or sidecar read behavior, keeping it below a 5.

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?

Purpose is front-loaded, followed by state semantics, param docs, and the return shape in a tight flow with no filler. The lone blemish is the internal ticket reference (#141 C2), which is noise an agent gains nothing from.

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

Completeness4/5

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

For a simple read-only predicate with no output schema, the description covers the essential purpose, state rules, required params, and even the return keys {ok, editable, state}. Only the workspace parameter and any registry-error behavior are left to the schema/annotations, a minor gap.

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 low (33%), so the description must compensate, and it does for the two required params: registry ("path to the items.json sidecar") and item ("the item id to check") get real meaning beyond the bare schema titles. The third param, workspace, is only documented in the schema, so the description doesn't fully cover all parameters.

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 names a specific verb+resource in plain terms ("the 'is this editable?' check a builder runs before writing") and immediately pins the semantics to lifecycle state (editable only in_work). This lets an agent distinguish it from mutation siblings like lifecycle_transition and lifecycle_apply_change without opening any schema.

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?

The phrase "the cheap check a builder runs before writing" gives a clear call-site condition (run it before a write). However, it names no explicit alternative or when-not-to-call exclusion, leaving the agent to infer that other lifecycle tools handle the actual transitions.

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