Skip to main content
Glama
targetprocess-mcp-server

targetprocess-mcp-server

Create a formatted feature

create_formatted_feature

Creates a Targetprocess Feature with a structured, template-driven description and required NFR rows so cross-cutting constraints, risks, and open questions stay testable and auditable.

Instructions

Create a new Feature in Targetprocess with a structured, template-driven description (feature-level TDRE), assembled from discrete sections and stored as HTML. Features sit above user stories — this template isn't about writing Gherkin for individual behaviors (that belongs on child stories); it's about tracking cross-cutting constraints, risks, and open questions to a testable/decided state before they get lost across many separate stories. Fill in each field to this quality bar: 1) Header — "businessBackground" is a 1-2 sentence value statement: who benefits and why; 2) Definitions — cross-cutting terms used across multiple child stories, so they aren't redefined at every story level; if none apply, OMIT "definitions" entirely (do not send an empty section); 3) Scope & Boundaries — what this feature explicitly includes/excludes, to stop child stories drifting into adjacent features; omit if genuinely trivial; 4) Non-Functional Requirements ("nonFunctionalRequirements") — this is the core of the template and doubles as ISO 27001:2022 audit evidence that NFRs (including information security, per Annex A Control 5.8) are considered at design time, not bolted on after. EVERY feature MUST include these four fixed rows, worded exactly as below (do not reword the questions — consistency in the questions is what makes them auditable), each answered SPECIFICALLY for this feature in "storyOrOwner" — a real, checkable answer (e.g. which systems/data/roles are involved), never a generic "considered" placeholder: - area "System performance" / requirement "What does this feature add or change in terms of load, queries, polling, rendering etc., and what's the expected impact, if any?"; - area "Information security (ISO 27001:2022 Annex A 5.8)" / requirement "What personal or sensitive data does this feature touch, and what protects its privacy, confidentiality, integrity and availability?"; - area "Quality control" / requirement "How will this feature's behaviour and failures be measured or tested, and what happens when it fails?"; - area "Service logging" / requirement "What events or states should be logged so product support can diagnose an issue without reproducing it manually?"; For each row, set status to "Covered" (storyOrOwner holds the specific answer, or the child story/scenario that proves it), "Gap" (no answer/story yet — storyOrOwner names who should follow up), or "Decision needed" (genuinely open, not answerable yet). If any of the four is unclear, follow-up owner in rather than guessing — he's the named escalation contact, not a mandatory sign-off gate. Additional NFR categories beyond these four (Compliance, Billing, Operational, etc.) can still be added as extra rows when relevant, using the same Covered/Gap/Decision-needed treatment; 5) Cross-Cutting Scenarios — ONLY for behavior spanning multiple child stories that wouldn't naturally sit in any one of them (e.g. tenant isolation across all stories); do not duplicate per-story Gherkin here; omit if none apply; 6) Child Stories ("childStories") — pull this from "get_feature_user_stories" / "get_not_covered_user_stories_in_feature" rather than retyping it; keep it as a live pointer, not a duplicate spec; normally empty when first creating the feature; 7) Open Questions / Risks ("openQuestions") — anything raised at feature conception that hasn't been resolved into either a Covered NFR row or a child story; this is the section most likely to get silently dropped — treat it as the running "not done yet" list until each line is promoted to a Covered NFR row; 8) References — mockup/spec links here, not inline in prose; 9) Notes — anything else that helps understand context but doesn't fit other sections; CRITICAL WORKFLOW: Before calling this tool, you MUST follow these steps: 1) IF the user specified an epic by name (not ID), resolve the epic ID first; 2) IF the user specified a release by name (not ID), call "get_current_releases" to resolve the release ID; 3) IF the user specified a team by name (not ID), call "get_teams" to find the matching team and use its ID as teamId; 4) IF the user specified a project by name (not ID), call "get_projects" to find the matching project and use its ID as projectId; 5) IF this feature already has child stories, call "get_feature_user_stories" and "get_not_covered_user_stories_in_feature" to build "childStories" instead of guessing coverage;

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": {
      "title": "<title>",
      "header": "<header>",
      "nonFunctionalRequirements": "<nonFunctionalRequirements>"
    },
    "name": "create_formatted_feature"
  }
}

Input Schema

NameRequiredDescriptionDefault
notesNoAnything else that helps understand context but does not fit other sections
scopeNoScope & Boundaries. Omit if genuinely trivial
titleYesFeature title
epicIdNoOptional Epic ID to link this feature to (e.g. 145636)
headerYesFeature header
teamIdNoOptional Team ID — defaults to TP_TEAM_ID from config
projectIdNoOptional Project ID — defaults to TP_PROJECT_ID from config
releaseIdNoOptional Release ID to link this feature to (e.g. 145200)
referencesNoLinks to specs/mockups (not inline in prose)
definitionsNoCross-cutting terms used across multiple child stories, avoiding re-defining the same term at every story level. Omit entirely if none apply
childStoriesNoPull this from "get_feature_user_stories" / "get_not_covered_user_stories_in_feature" rather than retyping it — a live pointer, not a duplicate spec. Normally empty when first creating the feature
openQuestionsNoAnything raised at feature conception not yet resolved into a Covered NFR row or a child story — the running "not done yet" list
crossCuttingScenariosNoOnly for behavior spanning multiple child stories that would not naturally sit in any single one of them. Do not duplicate per-story Gherkin here; omit if none apply
nonFunctionalRequirementsYesEvery NFR category converted from prose into a testable/decided row — the core of this template. MUST include the four fixed rows required for ISO 27001:2022 audit evidence: "System performance", "Information security (ISO 27001:2022 Annex A 5.8)", "Quality control", and "Service logging" — worded exactly, each answered specifically for this feature (escalate unclear items to story owner). Additional categories may be added beyond these four. Do not leave requirements as untested prose

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv2.8.2

TDQS

A3.9/5.0
Behavior3/5

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

No annotations are supplied, so the description carries the full behavioral burden. It discloses a great deal about required content and audit intent (ISO 27001:2022 Annex A 5.8 evidence) and mandates escalation rather than guessing, but says nothing about the response, permissions, idempotency, or what happens if required fixed NFR rows are malformed. The content-side disclosure is strong; the operational side is absent.

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

Conciseness3/5

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

The purpose is front-loaded and the numbered sections map cleanly onto the schema fields, which helps navigation. However, the text is roughly 600 words with heavy repetition of the same quality-bar rules and one garbled clause ("follow-up owner in rather than guessing — he's the named escalation contact") that appears to be an unfilled template placeholder, costing clarity.

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 14-parameter, deeply nested creation tool with no annotations and no output schema, the description covers the pre-call resolution workflow and the content standard thoroughly. It stops short of describing what a successful call returns or how validation failures surface, which is the remaining gap for a write tool of this complexity.

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 a baseline of 3 applies, but the description genuinely adds meaning: it fixes the exact wording of the four mandatory NFR rows, explains the Covered/Gap/Decision needed statuses with examples, prescribes that childStories be pulled from sibling tools rather than retyped, and directs references to links rather than prose. This goes beyond the schema's own field descriptions.

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?

The opening sentence gives a specific verb and resource ("Create a new Feature in Targetprocess") plus the distinguishing trait of a structured, template-driven description stored as HTML. It also explicitly contrasts the feature level with child-story Gherkin, so the agent can tell which level of artifact it is producing. It never names the plain sibling create_feature, so the choice between the two is left implicit.

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?

Usage is spelled out in detail: which sections to fill, which to omit when empty (definitions, scope, cross-cutting scenarios), when childStories should normally be empty, and a CRITICAL WORKFLOW block routing to get_current_releases, get_teams, get_projects and get_feature_user_stories before calling. That is explicit when/when-not guidance plus named alternatives.

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