targetprocess-mcp-server 2.6.0 → 2.6.2

package/README.md

@@ -42,6 +42,7 @@ Releases
 - `get_release_open_user_stories` — Get only active/open user stories for a release (name, withDescription, optional results)
 
 Features
+- `get_feature_content` — Get a Targetprocess Feature by ID, including description, state, and progress (id)
 - `get_feature_user_stories` — Get all user stories for a feature by its ID (id)
 - `get_not_covered_user_stories_in_feature` — Get user stories in a feature not yet covered by tests, includes `covered` field based on "Test Automation" custom field (id)
 
@@ -91,7 +92,7 @@ Cards — Write
 - `create_user_story` — Create a new user story (title, optional description, optional featureId, optional releaseId, optional projectId, optional teamId)  
 > [!NOTE]  
 > `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config  
-- `create_formatted_user_story` — Create a new user story with a structured template description (title, header object with asA/iWant/soThat, acceptanceCriteria array, scenarios array with Gherkin steps, optional definitions, examplesTable, edgeCases, references, notes, optional featureId, releaseId, projectId, teamId)  
+- `create_formatted_user_story` — Create a new user story with a structured template description in Header → Definitions → Scenarios → Examples Table → Edge Cases → Acceptance Criteria → References → Notes order (title, header object with asA/iWant/soThat, scenarios array with Gherkin steps, acceptanceCriteria array, optional definitions, examplesTable, edgeCases, references, notes, optional featureId, releaseId, projectId, teamId)  
 > [!NOTE]  
 > `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config  
 - `format_existing_user_story` — Re-format the description of an existing user story using the structured template (id, header object with asA/iWant/soThat, acceptanceCriteria array, scenarios array with Gherkin steps, optional title, definitions, examplesTable, edgeCases, references, notes)
@@ -102,6 +103,8 @@ Cards — Write
 - `create_feature` — Create a new feature (title, optional description, optional epicId, optional releaseId, optional projectId, optional teamId)  
 > [!NOTE]  
 > `projectId` and `teamId` are optional — fall back to `TP_PROJECT_ID` and `TP_TEAM_ID` from config  
+- `create_formatted_feature` — Create a new feature with a feature-level TDRE template in Header → Definitions → Scope & Boundaries → Non-Functional Requirements → Cross-Cutting Scenarios → Child Stories → Open Questions/Risks → References → Notes order (title, header object with businessBackground, nonFunctionalRequirements array with area/requirement/status/storyOrOwner, optional definitions, scope, crossCuttingScenarios, childStories, openQuestions, references, notes, optional epicId, releaseId, projectId, teamId)  
+- `update_feature` — Update a feature card with data provided from user input; pass only the fields to change (id, optional title, optional description, optional epicId, optional releaseId, optional projectId, optional teamId, optional entityStateId, optional tags, optional teamIterationId)  
 - `create_test_plan` — Create a test plan linked to a UserStory, Bug, or Feature (title, resourceId, optional resourceType, optional description/startDate/endDate)  
 > [!NOTE]  
 > requires `TP_PROJECT_ID`, 

package/build/handlers/create_formatted_feature.js

@@ -0,0 +1,81 @@
+const gherkinBlock = (items) => items.map((s, indx) => `<div><strong>Scenario ${indx + 1} - ${s.name}:</strong></div><div>${s.steps.map(step => `<div>\t${step}</div>`).join('\n')}</div>`).join('<br>');
+export async function handleCreateFormattedFeature(tp, params) {
+    const { title, header, definitions, scope, nonFunctionalRequirements, crossCuttingScenarios, childStories, openQuestions, references, notes, epicId, releaseId, projectId, teamId } = params;
+    const parts = ['<div>'];
+    parts.push('<h3>Header</h3>');
+    if (header.featureId)
+        parts.push(`<p><strong>Feature ID:</strong> ${header.featureId}</p>`);
+    parts.push(`<p><strong>Business Background:</strong> ${header.businessBackground}</p>`);
+    if (definitions && definitions.length > 0) {
+        parts.push('<h3>Definitions</h3>');
+        parts.push('<div>');
+        for (const def of definitions) {
+            parts.push(`<p><strong>${def.term}</strong> — ${def.description}</p>`);
+        }
+        parts.push('</div>');
+    }
+    if (scope && ((scope.includes?.length ?? 0) > 0 || (scope.excludes?.length ?? 0) > 0)) {
+        parts.push('<h3>Scope & Boundaries</h3>');
+        if (scope.includes && scope.includes.length > 0) {
+            parts.push('<p><strong>Includes:</strong></p>');
+            parts.push('<ul>');
+            for (const item of scope.includes)
+                parts.push(`<li>${item}</li>`);
+            parts.push('</ul>');
+        }
+        if (scope.excludes && scope.excludes.length > 0) {
+            parts.push('<p><strong>Excludes:</strong></p>');
+            parts.push('<ul>');
+            for (const item of scope.excludes)
+                parts.push(`<li>${item}</li>`);
+            parts.push('</ul>');
+        }
+    }
+    parts.push('<h3>Non-Functional Requirements</h3>');
+    parts.push('<table><tr><th>NFR Area</th><th>Requirement</th><th>Status</th><th>Story / Owner</th></tr>');
+    for (const nfr of nonFunctionalRequirements) {
+        parts.push(`<tr><td>${nfr.area}</td><td>${nfr.requirement}</td><td>${nfr.status}</td><td>${nfr.storyOrOwner}</td></tr>`);
+    }
+    parts.push('</table>');
+    if (crossCuttingScenarios && crossCuttingScenarios.length > 0) {
+        parts.push('<h3>Cross-Cutting Scenarios</h3>');
+        parts.push(gherkinBlock(crossCuttingScenarios));
+    }
+    if (childStories && childStories.length > 0) {
+        parts.push('<h3>Child Stories</h3>');
+        parts.push('<ul>');
+        for (const story of childStories) {
+            parts.push(`<li>[${story.covered ? 'x' : ' '}] ${story.id} — ${story.name}${story.covered ? ' (covered)' : ' (not yet covered by tests)'}</li>`);
+        }
+        parts.push('</ul>');
+    }
+    if (openQuestions && openQuestions.length > 0) {
+        parts.push('<h3>Open Questions / Risks</h3>');
+        parts.push('<ul>');
+        for (const question of openQuestions)
+            parts.push(`<li>${question}</li>`);
+        parts.push('</ul>');
+    }
+    if (references) {
+        parts.push('<h3>References</h3>');
+        parts.push(`<p>${references}</p>`);
+    }
+    if (notes) {
+        parts.push('<h3>Notes</h3>');
+        parts.push(`<p>${notes}</p>`);
+    }
+    parts.push('</div>');
+    const description = parts.join('\n');
+    const featureResponse = await tp.createFeature({ title, description, epicId, releaseId, projectId, teamId });
+    if (!featureResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to create formatted feature "${title}"\n JSON: ${JSON.stringify(featureResponse, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(featureResponse) }],
+    };
+}

package/build/handlers/create_formatted_user_story.js

@@ -0,0 +1,55 @@
+const gherkinBlock = (items) => items.map((s, indx) => `<div><strong>Scenario ${indx + 1} - ${s.name}:</strong></div><div>${s.steps.map(step => `<div>\t${step}</div>`).join('\n')}</div>`).join('<br>');
+export async function handleCreateFormattedUserStory(tp, params) {
+    const { title, header, definitions, scenarios, examplesTable, edgeCases, acceptanceCriteria, references, notes, featureId, releaseId, projectId, teamId, tags, teamIterationId } = params;
+    const parts = ['<div>'];
+    parts.push('<h3>Header</h3>');
+    if (header.storyId)
+        parts.push(`<p><strong>Story ID:</strong> ${header.storyId}</p>`);
+    parts.push(`<p>As a ${header.asA} <br> I want ${header.iWant} <br> so that ${header.soThat}</p>`);
+    if (definitions && definitions.length > 0) {
+        parts.push('<h3>Definitions</h3>');
+        parts.push('<div>');
+        for (const def of definitions) {
+            parts.push(`<p><strong>${def.term}</strong> — ${def.description}</p>`);
+        }
+        parts.push('</div>');
+    }
+    parts.push('<h3>Scenarios</h3>');
+    parts.push(gherkinBlock(scenarios));
+    if (examplesTable) {
+        parts.push('<h3>Examples Table</h3>');
+        parts.push(`<pre>${examplesTable}</pre>`);
+    }
+    if (edgeCases && edgeCases.length > 0) {
+        parts.push('<h3>Edge Cases</h3>');
+        parts.push(gherkinBlock(edgeCases));
+    }
+    parts.push('<h3>Acceptance Criteria</h3>');
+    parts.push('<ol>');
+    for (const criterion of acceptanceCriteria) {
+        parts.push(`<li>${criterion}</li>`);
+    }
+    parts.push('</ol>');
+    if (references) {
+        parts.push('<h3>References</h3>');
+        parts.push(`<p>${references}</p>`);
+    }
+    if (notes) {
+        parts.push('<h3>Notes</h3>');
+        parts.push(`<p>${notes}</p>`);
+    }
+    parts.push('</div>');
+    const description = parts.join('\n');
+    const userStoryResponse = await tp.createUserStory({ title, description, featureId, releaseId, projectId, teamId, tags, teamIterationId });
+    if (!userStoryResponse) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to create formatted user story "${title}"\n JSON: ${JSON.stringify(userStoryResponse, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(userStoryResponse) }],
+    };
+}

package/build/handlers/delete_card.js

@@ -0,0 +1,19 @@
+export async function handleDeleteCard(tp, params) {
+    const result = await tp.deleteCard(params);
+    if (!result.ok) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to delete ${params.type} id: ${params.id}\n` +
+                        `HTTP status: ${result.status}\n` +
+                        `Response body: ${result.body}`
+                }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ deleted: true, id: Number(params.id), type: params.type, card: result.data })
+            }],
+    };
+}

package/build/handlers/get_feature_content.js

@@ -0,0 +1,38 @@
+import { JSDOM } from 'jsdom';
+export async function handleGetFeatureContent(tp, id) {
+    const feature = await tp.getFeature(id);
+    if (!feature) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get feature, id: ${id}\n JSON: ${JSON.stringify(feature, null, 2)}`
+                }],
+        };
+    }
+    const result = {
+        name: feature.Name,
+        id: feature.Id,
+        description: '',
+        entityState: feature.EntityState?.Name,
+        release: feature.Release?.Name,
+        epic: feature.Epic?.Name,
+        progress: feature.Progress,
+        effort: feature.Effort,
+        customFields: feature.CustomFields,
+    };
+    const description = feature.Description || '';
+    if (description) {
+        try {
+            const dom = new JSDOM(`<html><body><div id="content">${description}</div></body></html>`);
+            const text = dom.window.document.getElementById('content')?.textContent;
+            if (text)
+                result.description = text;
+        }
+        catch (error) {
+            console.error('Error parsing feature description:', error);
+        }
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+    };
+}

package/build/handlers/get_team_iterations.js

@@ -0,0 +1,30 @@
+export async function handleGetTeamIterations(tp, params) {
+    const response = await tp.getTeamIterations(params);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to get team iterations, JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    const items = response.Items || [];
+    if (items.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'No team iterations found' }],
+        };
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(items.map((i) => ({
+                    id: i.Id,
+                    name: i.Name,
+                    startDate: i.StartDate,
+                    endDate: i.EndDate,
+                    teamId: i.Team?.Id,
+                    teamName: i.Team?.Name,
+                }))),
+            }],
+    };
+}

package/build/handlers/update_feature.js

@@ -0,0 +1,14 @@
+export async function handleUpdateFeature(tp, params) {
+    const response = await tp.updateFeature(params);
+    if (!response) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Failed to update feature id: ${params.id}\n JSON: ${JSON.stringify(response, null, 2)}`
+                }],
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(response) }],
+    };
+}

package/build/index.js

@@ -20,11 +20,15 @@ import { handleGetReleaseOpenBugs } from "./handlers/get_release_open_bugs.js";
 import { handleGetReleaseOpenUserStories } from "./handlers/get_release_open_user_stories.js";
 import { handleGetUsers } from "./handlers/get_users.js";
 import { handleGetTeams, handleGetTeamsAndTeamAssignments } from "./handlers/get_teams.js";
+import { handleGetTeamIterations } from "./handlers/get_team_iterations.js";
 import { handleAddComment } from "./handlers/add_comment.js";
 import { handleGetUserStoryComments } from "./handlers/get_user_story_comments.js";
 import { handleGetBugComments } from "./handlers/get_bug_comments.js";
 import { handleCreateBug } from "./handlers/create_bug.js";
 import { handleCreateUserStory } from "./handlers/create_user_story.js";
+import { handleCreateFormattedUserStory } from "./handlers/create_formatted_user_story.js";
+import { handleCreateFormattedFeature } from "./handlers/create_formatted_feature.js";
+import { handleUpdateFeature } from "./handlers/update_feature.js";
 import { handleCreateFeature } from "./handlers/create_feature.js";
 import { handleCreateEpic } from "./handlers/create_epic.js";
 import { handleGetEpicContent } from "./handlers/get_epic_content.js";
@@ -38,12 +42,14 @@ import { handleListMyBugs } from "./handlers/list_my_bugs.js";
 import { handleLogTime } from "./handlers/log_time.js";
 import { handleGetMyTimeLogs } from "./handlers/get_my_time_logs.js";
 import { handleGetFeatureUserStories } from "./handlers/get_feature_user_stories.js";
+import { handleGetFeatureContent } from "./handlers/get_feature_content.js";
 import { handleGetUserStoryBugs } from "./handlers/get_user_story_bugs.js";
 import { handleGetCardCurrentStatus } from "./handlers/get_card_current_status.js";
 import { handleUpdateUserStorySubState } from "./handlers/update_user_story_sub_state.js";
 import { handleGetCardRelations } from "./handlers/get_card_relations.js";
 import { handleCreateCardRelation } from "./handlers/create_card_relation.js";
 import { handleDeleteCardRelation } from "./handlers/delete_card_relation.js";
+import { handleDeleteCard } from "./handlers/delete_card.js";
 import { handleGetTestPlanById } from "./handlers/get_test_plan_by_id.js";
 import { handleGetTestPlanTestCasesById } from "./handlers/get_test_plan_test_cases_by_id.js";
 import { handleGetTestPlanTestCasesWithStepsById } from "./handlers/get_test_plan_test_cases_with_steps_by_id.js";
@@ -409,7 +415,8 @@ server.registerTool('update_bug', {
       CRITICAL WORKFLOW: Before calling this tool, you MUST follow these steps:
         1) IF the user specified a team by name (not ID), call "get_teams" to find the matching team and use its ID as teamId;
         2) IF the user specified a project by name (not ID), call "get_projects" to find the matching project and use its ID as projectId;
-        3) IF the user specified a state by name (not ID), call "get_bug_workflows" to find the matching state and use its ID as entityStateId;`,
+        3) IF the user specified a state by name (not ID), call "get_bug_workflows" to find the matching state and use its ID as entityStateId;
+        4) IF the user specified a sprint/iteration by name, call "get_team_iterations" to find the matching iteration and use its ID as teamIterationId;`,
     inputSchema: {
         id: z.string()
             .min(5)
@@ -443,8 +450,14 @@ server.registerTool('update_bug', {
         entityStateId: z.string()
             .optional()
             .describe('Optional Entity State ID — if user gave a state name, resolve it via "get_bug_workflows" first; defaults to "Done"'),
+        tags: z.string()
+            .optional()
+            .describe('Optional comma-separated tags to apply, e.g. "regression, mobile"'),
+        teamIterationId: z.string()
+            .optional()
+            .describe('Optional Team Iteration (sprint) ID — resolve it via "get_team_iterations" first'),
     },
-}, async ({ id, title, bugContent, origin, projectId, teamId, entityStateId }) => handleUpdateBug(tp, { id, title, bugContent, origin, projectId, teamId, entityStateId }));
+}, async ({ id, title, bugContent, origin, projectId, teamId, entityStateId, tags, teamIterationId }) => handleUpdateBug(tp, { id, title, bugContent, origin, projectId, teamId, entityStateId, tags, teamIterationId }));
 server.registerTool('update_user_story_state', {
     title: 'Update a user story card sub state',
     description: `Update a user story card sub state with data provided from user input.
@@ -474,7 +487,8 @@ server.registerTool('update_user_story', {
       CRITICAL WORKFLOW: Before calling this tool, you MUST follow these steps:
         1) IF the user specified a team by name (not ID), call "get_teams" to find the matching team and use its ID as teamId;
         2) IF the user specified a project by name (not ID), call "get_projects" to find the matching project and use its ID as projectId;
-        3) IF the user specified a state by name (not ID), call "get_user_story_workflows" to find the matching state and use its ID as entityStateId;`,
+        3) IF the user specified a state by name (not ID), call "get_user_story_workflows" to find the matching state and use its ID as entityStateId;
+        4) IF the user specified a sprint/iteration by name, call "get_team_iterations" to find the matching iteration and use its ID as teamIterationId;`,
     inputSchema: {
         id: z.string()
             .min(5)
@@ -498,9 +512,15 @@ server.registerTool('update_user_story', {
         featureId: z.string()
             .optional()
             .describe('Optional Feature ID — moves this user story to the specified feature'),
+        tags: z.string()
+            .optional()
+            .describe('Optional comma-separated tags to apply, e.g. "regression, mobile"'),
+        teamIterationId: z.string()
+            .optional()
+            .describe('Optional Team Iteration (sprint) ID — resolve it via "get_team_iterations" first'),
     },
-}, async ({ id, title, description, projectId, teamId, entityStateId, featureId }) => {
-    const response = await tp.updateUserStory({ id, title, description, projectId, teamId, entityStateId, featureId });
+}, async ({ id, title, description, projectId, teamId, entityStateId, featureId, tags, teamIterationId }) => {
+    const response = await tp.updateUserStory({ id, title, description, projectId, teamId, entityStateId, featureId, tags, teamIterationId });
     if (!response) {
         return {
             content: [{
@@ -523,7 +543,8 @@ server.registerTool('create_bug', {
       CRITICAL WORKFLOW: Before calling this tool, you MUST follow these steps:
         1) format the new bug inside html <div> tags with Environment(describes where bug was found, dev, feature, review or uat Environment), Issue Description, Steps to Reproduce, Expected Behavior, Actual Behavior and Attachments sections (note: section titles should be wrapped in <h3> tags, e.g. <h3>Issue Description</h3>, step to reproduce should be wrapped in <ol>);
         2) IF the user specified a team by name (not ID), call "get_teams" to find the matching team and use its ID as teamId;
-        3) IF the user specified a project by name (not ID), call "get_projects" to find the matching project and use its ID as projectId;`,
+        3) IF the user specified a project by name (not ID), call "get_projects" to find the matching project and use its ID as projectId;
+        4) IF the user specified a sprint/iteration by name, call "get_team_iterations" to find the matching iteration and use its ID as teamIterationId;`,
     inputSchema: {
         title: z.string()
             .describe('Bug card title that summarizes the problem in concise, descriptive, and actionable manner, enabling a developer to understand the issue without opening the report'),
@@ -552,11 +573,18 @@ server.registerTool('create_bug', {
         entityStateId: z.string()
             .optional()
             .describe('Optional Entity State ID — if user gave a state name, resolve it via "get_bug_workflows" first; defaults to "Done"'),
+        tags: z.string()
+            .optional()
+            .describe('Optional comma-separated tags to apply, e.g. "regression, mobile"'),
+        teamIterationId: z.string()
+            .optional()
+            .describe('Optional Team Iteration (sprint) ID — resolve it via "get_team_iterations" first'),
     },
-}, async ({ title, bugContent, origin, projectId, teamId, entityStateId }) => handleCreateBug(tp, { title, bugContent, origin, projectId, teamId, entityStateId }));
+}, async ({ title, bugContent, origin, projectId, teamId, entityStateId, tags, teamIterationId }) => handleCreateBug(tp, { title, bugContent, origin, projectId, teamId, entityStateId, tags, teamIterationId }));
 server.registerTool('create_user_story', {
     title: 'Create a new user story',
-    description: `Create a new user story in Targetprocess.`,
+    description: `Create a new user story in Targetprocess.
+      CRITICAL WORKFLOW: Before calling this tool, IF the user specified a sprint/iteration by name, call "get_team_iterations" to find the matching iteration and use its ID as teamIterationId.`,
     inputSchema: {
         title: z.string()
             .describe('User story title'),
@@ -579,17 +607,32 @@ server.registerTool('create_user_story', {
         teamId: z.string()
             .optional()
             .describe('Optional Team ID — defaults to TP_TEAM_ID from config'),
+        tags: z.string()
+            .optional()
+            .describe('Optional comma-separated tags to apply, e.g. "regression, mobile"'),
+        teamIterationId: z.string()
+            .optional()
+            .describe('Optional Team Iteration (sprint) ID — resolve it via "get_team_iterations" first'),
     },
-}, async ({ title, description, featureId, releaseId, projectId, teamId }) => handleCreateUserStory(tp, { title, description, featureId, releaseId, projectId, teamId }));
+}, async ({ title, description, featureId, releaseId, projectId, teamId, tags, teamIterationId }) => handleCreateUserStory(tp, { title, description, featureId, releaseId, projectId, teamId, tags, teamIterationId }));
 server.registerTool('create_formatted_user_story', {
     title: 'Create a formatted user story',
-    description: `Create a new user story in Targetprocess with a structured, template-driven description.
-      The description is assembled from discrete sections (header, definitions, acceptance criteria, Gherkin scenarios, edge cases, references, notes) and stored as HTML.
+    description: `Create a new user story in Targetprocess with a structured, template-driven description, assembled from discrete sections and stored as HTML.
+      Fill in each field to this quality bar:
+        1) Header — "asA" and "iWant" must be filled in, and "soThat" MUST be a real business outcome, not a restatement of "iWant";
+        2) Definitions — check for jargon, feature flags, module names, and acronyms; if none apply, OMIT the "definitions" field entirely (do not send an empty section);
+        3) Scenarios (write these BEFORE acceptanceCriteria) — at least one Gherkin scenario per distinct behavior; each scenario has exactly ONE "Then" outcome (split it into two scenarios if it needs two); avoid vague verbs like "system validates input" — spell out exactly what "validates" means in the "Then" step;
+        4) Examples Table — if any behavior is described as "supports various formats/roles/states", convert it into a Scenario Outline (one of the "scenarios" entries) plus a matching "examplesTable" with real values; if no parameterized behavior exists, OMIT "examplesTable";
+        5) Edge Cases — MANDATORY (include at least one error-state scenario and one boundary-condition scenario in "edgeCases") if the story touches validation/input handling, permissions/roles, or external data/integrations; otherwise OMIT "edgeCases";
+        6) Acceptance Criteria — every bullet MUST be traceable to a specific scenario or edge case above; if a bullet isn't backed by a scenario, it isn't a criterion yet — put it in "notes" as a flagged gap instead;
+        7) References — put mockup/spec links here, not inline in prose;
+        8) Notes — capture open questions or known constraints here; don't let them hide inside acceptanceCriteria;
       CRITICAL WORKFLOW: Before calling this tool, you MUST follow these steps:
         1) IF the user specified a feature by name (not ID), call "get_feature_user_stories" or "search_tp_cards" to resolve the feature ID;
         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;`,
+        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 the user specified a sprint/iteration by name, call "get_team_iterations" to find the matching iteration and use its ID as teamIterationId;`,
     inputSchema: {
         title: z.string()
             .describe('User story title'),
@@ -602,7 +645,7 @@ server.registerTool('create_formatted_user_story', {
             iWant: z.string()
                 .describe('Goal — the "I want ..." part'),
             soThat: z.string()
-                .describe('Benefit — the "so that ..." part'),
+                .describe('Benefit — the "so that ..." part. MUST be a real business outcome, not a restatement of "iWant"'),
         })
             .describe('Story header following the As a / I want / so that format'),
         definitions: z.array(z.object({
@@ -610,22 +653,21 @@ server.registerTool('create_formatted_user_story', {
                 .describe('The term, module name, or feature flag being defined'),
             description: z.string()
                 .describe('Explanation of the term'),
-        })),
-        acceptanceCriteria: z.array(z.string())
-            .min(1)
-            .describe('Bullet checklist items for quick review sign-off — each string is one criterion'),
+        }))
+            .optional()
+            .describe('Jargon, feature flags, module names, or acronyms that need defining. Omit entirely if none apply — do not send an empty section'),
         scenarios: z.array(z.object({
             name: z.string()
                 .describe('Scenario name'),
             steps: z.array(z.string())
                 .min(1)
-                .describe('Gherkin steps — each string is a full step line, e.g. "Given I am on the login page"'),
+                .describe('Gherkin steps — each string is a full step line, e.g. "Given I am on the login page". Exactly one "Then" step per scenario; split into another scenario if a second outcome is needed. Avoid vague verbs ("validates") — spell out what happens'),
         }))
             .min(1)
-            .describe('Gherkin scenario blocks, one per behavior branch'),
+            .describe('Gherkin scenario blocks, one per distinct behavior. Write these before acceptanceCriteria'),
         examplesTable: z.string()
             .optional()
-            .describe('Examples table for parameterized or matrix behavior (plain text or Gherkin Examples: table format)'),
+            .describe('Examples: table with real values backing a Scenario Outline for parameterized/matrix behavior (e.g. "supports various formats/roles/states"). Omit if no parameterized behavior exists'),
         edgeCases: z.array(z.object({
             name: z.string()
                 .describe('Edge case scenario name'),
@@ -634,13 +676,16 @@ server.registerTool('create_formatted_user_story', {
                 .describe('Gherkin steps for this edge case'),
         }))
             .optional()
-            .describe('Explicit edge case or boundary condition scenarios'),
+            .describe('Explicit edge case or boundary condition scenarios. MANDATORY — at least one error-state and one boundary-condition scenario — if the story touches validation/input handling, permissions/roles, or external data/integrations; omit otherwise'),
+        acceptanceCriteria: z.array(z.string())
+            .min(1)
+            .describe('Bullet checklist items for quick review sign-off — each string is one criterion. Every bullet MUST be traceable to a specific scenario or edge case above'),
         references: z.string()
             .optional()
             .describe('Links to Axure mockups or other external references (not inline in prose)'),
         notes: z.string()
             .optional()
-            .describe('Anything that helps understand the story context but does not fit other sections'),
+            .describe('Open questions or known constraints that do not fit other sections — do not let these hide inside acceptanceCriteria'),
         featureId: z.string()
             .min(5)
             .max(9)
@@ -657,64 +702,121 @@ server.registerTool('create_formatted_user_story', {
         teamId: z.string()
             .optional()
             .describe('Optional Team ID — defaults to TP_TEAM_ID from config'),
+        tags: z.string()
+            .optional()
+            .describe('Optional comma-separated tags to apply, e.g. "regression, mobile"'),
+        teamIterationId: z.string()
+            .optional()
+            .describe('Optional Team Iteration (sprint) ID — resolve it via "get_team_iterations" first'),
     },
-}, async ({ title, header, definitions, acceptanceCriteria, scenarios, examplesTable, edgeCases, references, notes, featureId, releaseId, projectId, teamId }) => {
-    const gherkinBlock = (items) => items.map((s, indx) => `<div><strong>Scenario ${indx + 1} - ${s.name}:</strong></div><div>${s.steps.map(step => `<div>\t${step}</div>`).join('\n')}</div>`).join('<br>');
-    const parts = ['<div>'];
-    parts.push('<h3>Header</h3>');
-    if (header.storyId)
-        parts.push(`<p><strong>Story ID:</strong> ${header.storyId}</p>`);
-    parts.push(`<p>As a ${header.asA} <br> I want ${header.iWant} <br> so that ${header.soThat}</p>`);
-    if (definitions) {
-        parts.push('<h3>Definitions</h3>');
-        parts.push(`<div>`);
-        for (const def of definitions) {
-            parts.push(`<p><strong>${def.term}</strong> — ${def.description}</p>`);
-        }
-        parts.push(`</div>`);
-    }
-    parts.push('<h3>Acceptance Criteria</h3>');
-    parts.push('<ol>');
-    for (const criterion of acceptanceCriteria) {
-        parts.push(`<li>${criterion}</li>`);
-    }
-    parts.push('</ol>');
-    parts.push('<h3>Scenarios</h3>');
-    parts.push(gherkinBlock(scenarios));
-    if (examplesTable) {
-        parts.push('<h3>Examples</h3>');
-        parts.push(`<pre>${examplesTable}</pre>`);
-    }
-    if (edgeCases && edgeCases.length > 0) {
-        parts.push('<h3>Edge Cases</h3>');
-        parts.push(gherkinBlock(edgeCases));
-    }
-    if (references) {
-        parts.push('<h3>References</h3>');
-        parts.push(`<p>${references}</p>`);
-    }
-    if (notes) {
-        parts.push('<h3>Notes</h3>');
-        parts.push(`<p>${notes}</p>`);
-    }
-    parts.push('</div>');
-    const description = parts.join('\n');
-    const userStoryResponse = await tp.createUserStory({ title, description, featureId, releaseId, projectId, teamId });
-    if (!userStoryResponse) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Failed to create formatted user story "${title}"\n JSON: ${JSON.stringify(userStoryResponse, null, 2)}`
-                }]
-        };
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(userStoryResponse)
-            }],
-    };
-});
+}, async ({ title, header, definitions, scenarios, examplesTable, edgeCases, acceptanceCriteria, references, notes, featureId, releaseId, projectId, teamId, tags, teamIterationId }) => handleCreateFormattedUserStory(tp, { title, header, definitions, scenarios, examplesTable, edgeCases, acceptanceCriteria, references, notes, featureId, releaseId, projectId, teamId, tags, teamIterationId }));
+server.registerTool('create_formatted_feature', {
+    title: 'Create a formatted feature',
+    description: `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") — every NFR category (Security, Compliance, Billing, Operational, etc.) MUST be converted from prose into one row with status "Covered" (link the child story/scenario that proves it in storyOrOwner), "Gap" (no story covers it yet — storyOrOwner names who should follow up), or "Decision needed" (genuinely still open, not testable until resolved). This is the core of the template — never leave an NFR as untested prose;
+        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;`,
+    inputSchema: {
+        title: z.string()
+            .describe('Feature title'),
+        header: z.object({
+            featureId: z.string()
+                .optional()
+                .describe('Feature ID if already known (e.g. TP-145636), omit for new features'),
+            businessBackground: z.string()
+                .describe('1-2 sentence value statement — who benefits and why'),
+        })
+            .describe('Feature header'),
+        definitions: z.array(z.object({
+            term: z.string()
+                .describe('The term, module name, or feature flag being defined'),
+            description: z.string()
+                .describe('Explanation of the term'),
+        }))
+            .optional()
+            .describe('Cross-cutting terms used across multiple child stories, avoiding re-defining the same term at every story level. Omit entirely if none apply'),
+        scope: z.object({
+            includes: z.array(z.string())
+                .optional()
+                .describe('What this feature explicitly includes'),
+            excludes: z.array(z.string())
+                .optional()
+                .describe('What this feature explicitly excludes — prevents child stories drifting into adjacent features'),
+        })
+            .optional()
+            .describe('Scope & Boundaries. Omit if genuinely trivial'),
+        nonFunctionalRequirements: z.array(z.object({
+            area: z.string()
+                .describe('NFR category, e.g. Security, Compliance, Billing, Operational'),
+            requirement: z.string()
+                .describe('The requirement, stated so it can be judged Covered/Gap/Decision needed'),
+            status: z.enum(["Covered", "Gap", "Decision needed"])
+                .describe('Covered = a child story/scenario proves it; Gap = no story covers it yet; Decision needed = still open — not testable until resolved'),
+            storyOrOwner: z.string()
+                .describe('If Covered, the child story ID/scenario that proves it; if Gap or Decision needed, who owns the follow-up (e.g. "Needs legal/BA follow-up")'),
+        }))
+            .min(1)
+            .describe('Every NFR category converted from prose into a testable/decided row — the core of this template. Do not leave requirements as untested prose'),
+        crossCuttingScenarios: z.array(z.object({
+            name: z.string()
+                .describe('Scenario name'),
+            steps: z.array(z.string())
+                .min(1)
+                .describe('Gherkin steps — each string is a full step line'),
+        }))
+            .optional()
+            .describe('Only 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'),
+        childStories: z.array(z.object({
+            id: z.string()
+                .describe('Child story ID (e.g. 145789)'),
+            name: z.string()
+                .describe('Child story title'),
+            covered: z.boolean()
+                .describe('Whether this story is covered by tests'),
+        }))
+            .optional()
+            .describe('Pull 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'),
+        openQuestions: z.array(z.string())
+            .optional()
+            .describe('Anything raised at feature conception not yet resolved into a Covered NFR row or a child story — the running "not done yet" list'),
+        references: z.string()
+            .optional()
+            .describe('Links to specs/mockups (not inline in prose)'),
+        notes: z.string()
+            .optional()
+            .describe('Anything else that helps understand context but does not fit other sections'),
+        epicId: z.string()
+            .min(5)
+            .max(9)
+            .optional()
+            .describe('Optional Epic ID to link this feature to (e.g. 145636)'),
+        releaseId: z.string()
+            .min(5)
+            .max(9)
+            .optional()
+            .describe('Optional Release ID to link this feature to (e.g. 145200)'),
+        projectId: z.string()
+            .optional()
+            .describe('Optional Project ID — defaults to TP_PROJECT_ID from config'),
+        teamId: z.string()
+            .optional()
+            .describe('Optional Team ID — defaults to TP_TEAM_ID from config'),
+    },
+}, async ({ title, header, definitions, scope, nonFunctionalRequirements, crossCuttingScenarios, childStories, openQuestions, references, notes, epicId, releaseId, projectId, teamId }) => handleCreateFormattedFeature(tp, { title, header, definitions, scope, nonFunctionalRequirements, crossCuttingScenarios, childStories, openQuestions, references, notes, epicId, releaseId, projectId, teamId }));
 server.registerTool('create_feature', {
     title: 'Create a new feature',
     description: `Create a new Feature in Targetprocess.`,
@@ -742,6 +844,54 @@ server.registerTool('create_feature', {
             .describe('Optional Team ID — defaults to TP_TEAM_ID from config'),
     },
 }, async ({ title, description, epicId, releaseId, projectId, teamId }) => handleCreateFeature(tp, { title, description, epicId, releaseId, projectId, teamId }));
+server.registerTool('update_feature', {
+    title: 'Update a feature card',
+    description: `Update a feature card with data provided from user input.
+      NOTE: pass only the fields that user wants to update.
+      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 the user specified a sprint/iteration by name, call "get_team_iterations" to find the matching iteration and use its ID as teamIterationId;`,
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(9)
+            .describe('Feature card ID (e.g. 145636)'),
+        title: z.string()
+            .optional()
+            .describe('Updated feature title'),
+        description: z.string()
+            .optional()
+            .describe('Updated feature description (format as HTML)'),
+        epicId: z.string()
+            .min(5)
+            .max(9)
+            .optional()
+            .describe('Optional Epic ID — moves this feature to the specified epic'),
+        releaseId: z.string()
+            .min(5)
+            .max(9)
+            .optional()
+            .describe('Optional Release ID to link this feature to'),
+        projectId: z.string()
+            .optional()
+            .describe('Optional Project ID — if user gave a project name, resolve it via "get_projects" first'),
+        teamId: z.string()
+            .optional()
+            .describe('Optional Team ID — if user gave a team name, resolve it via "get_teams" first'),
+        entityStateId: z.string()
+            .optional()
+            .describe('Optional Entity State ID — ask the user for the exact ID if given a state name; no dedicated feature-workflow lookup tool exists yet'),
+        tags: z.string()
+            .optional()
+            .describe('Optional comma-separated tags to apply, e.g. "regression, mobile"'),
+        teamIterationId: z.string()
+            .optional()
+            .describe('Optional Team Iteration (sprint) ID — resolve it via "get_team_iterations" first'),
+    },
+}, async ({ id, title, description, epicId, releaseId, projectId, teamId, entityStateId, tags, teamIterationId }) => handleUpdateFeature(tp, { id, title, description, epicId, releaseId, projectId, teamId, entityStateId, tags, teamIterationId }));
 server.registerTool('create_epic', {
     title: 'Create a new epic',
     description: `Create a new Epic in Targetprocess.`,
@@ -939,6 +1089,16 @@ server.registerTool('get_feature_user_stories', {
             .describe('TP feature ID (e.g. 145636)'),
     },
 }, async ({ id }) => handleGetFeatureUserStories(tp, id));
+server.registerTool('get_feature_content', {
+    title: 'Get TP feature content',
+    description: 'Get a Targetprocess Feature by ID, including description, state, and progress',
+    inputSchema: {
+        id: z.string()
+            .min(5)
+            .max(9)
+            .describe('TP feature ID (e.g. 145636)'),
+    },
+}, async ({ id }) => handleGetFeatureContent(tp, id));
 server.registerTool('get_user_story_bugs', {
     title: 'Get user story bugs',
     description: 'Get bugs linked to a TP user story by its ID',
@@ -961,6 +1121,16 @@ server.registerTool('get_teams', {
     title: 'Get teams',
     description: 'Get all Targetprocess teams',
 }, async () => handleGetTeams(tp));
+server.registerTool('get_team_iterations', {
+    title: 'Get team iterations',
+    description: `Get Targetprocess team iterations (sprints), optionally filtered by team. Use this to resolve a sprint/iteration name to an ID before calling create_user_story, create_bug, update_user_story, or update_bug with teamIterationId.
+      CRITICAL WORKFLOW: IF the user specified a team by name (not ID), call "get_teams" first to find the matching team and use its ID as teamId.`,
+    inputSchema: {
+        teamId: z.string()
+            .optional()
+            .describe('Optional Team ID to filter iterations by — resolve it via "get_teams" first'),
+    },
+}, async ({ teamId }) => handleGetTeamIterations(tp, { teamId }));
 server.registerTool('get_logged_in_user', {
     title: 'Get logged in user',
     description: 'Get logged in user',
@@ -1235,6 +1405,17 @@ server.registerTool('delete_card_relation', {
             .describe('The relation ID to delete (the "relationId" field from "get_card_relations", e.g. 20748)'),
     },
 }, async ({ relationId }) => handleDeleteCardRelation(tp, relationId));
+server.registerTool('delete_card', {
+    title: 'Delete a card (Bug, User Story, Feature, or Epic)',
+    description: `Delete (remove) a Targetprocess card by its ID. Works on Bugs, User Stories, Features, and Epics.
+      IF the type is uncertain, resolve it first via "search_tp_cards" or by fetching the card.`,
+    inputSchema: {
+        id: z.string()
+            .describe('The card ID to delete (e.g. 148980)'),
+        type: z.enum(["Bug", "UserStory", "Feature", "Epic"])
+            .describe('The entity type of the card being deleted'),
+    },
+}, async ({ id, type }) => handleDeleteCard(tp, { id, type }));
 server.registerTool('get_in_progress_tasks_and_bugs', {
     title: 'Get in-progress tasks and bugs for a user',
     description: 'Get all Tasks and Bugs currently in "In Progress" state assigned to a given user ID',

package/build/tp.js

@@ -24,6 +24,11 @@ export class TpClient {
         }
         return _url + "/?" + _urlParams.join("&");
     }
+    // Strips the access_token value out of a URL before it's logged, so the
+    // live TP credential never ends up in stderr/log files.
+    redact(url) {
+        return url.replace(this.token, "***");
+    }
     // @ts-ignore
     async getAll(params) {
         const allItems = [];
@@ -58,14 +63,14 @@ export class TpClient {
         }
         catch (error) {
             console.error("Error making TP request:", error);
-            console.error("Request URL:", _url);
+            console.error("Request URL:", this.redact(_url));
             return null;
         }
     }
     async post(params, data) {
         params.param["access_token"] = this.token;
         let _url = this.params(params);
-        console.error(JSON.stringify({ "TP_POST_URL": _url }));
+        console.error(JSON.stringify({ "TP_POST_URL": this.redact(_url) }));
         console.error(JSON.stringify({ "TP_POST_BODY": data }));
         try {
             const response = await fetch(_url, {
@@ -88,7 +93,7 @@ export class TpClient {
     async postRaw(params, data) {
         params.param["access_token"] = this.token;
         let _url = this.params(params);
-        console.error(JSON.stringify({ "TP_POST_URL": _url }));
+        console.error(JSON.stringify({ "TP_POST_URL": this.redact(_url) }));
         console.error(JSON.stringify({ "TP_POST_BODY": data }));
         try {
             const response = await fetch(_url, {
@@ -113,7 +118,7 @@ export class TpClient {
     async del(params) {
         params.param["access_token"] = this.token;
         let _url = this.params(params);
-        console.error(JSON.stringify({ "TP_DELETE_URL": _url }));
+        console.error(JSON.stringify({ "TP_DELETE_URL": this.redact(_url) }));
         try {
             const response = await fetch(_url, {
                 method: "DELETE",
@@ -227,7 +232,7 @@ export class TpClient {
             param: { "format": "json" },
         }, userStory);
     }
-    async updateUserStory({ id, title, description, projectId, teamId, entityStateId, featureId }) {
+    async updateUserStory({ id, title, description, projectId, teamId, entityStateId, featureId, tags, teamIterationId }) {
         const userStory = { "Id": id };
         if (title)
             userStory["Name"] = title;
@@ -241,12 +246,16 @@ export class TpClient {
             userStory["EntityState"] = { "Id": entityStateId };
         if (featureId)
             userStory["Feature"] = { "Id": featureId };
+        if (tags)
+            userStory["Tags"] = tags;
+        if (teamIterationId)
+            userStory["TeamIteration"] = { "Id": teamIterationId };
         return this.post({
             pathParam: ["UserStories"],
             param: { "format": "json" },
         }, userStory);
     }
-    async updateBug({ id, title, bugContent, origin, projectId, teamId, entityStateId }) {
+    async updateBug({ id, title, bugContent, origin, projectId, teamId, entityStateId, tags, teamIterationId }) {
         const bug = { "Id": id };
         if (title)
             bug["Name"] = title;
@@ -268,12 +277,16 @@ export class TpClient {
                 }];
         if (entityStateId)
             bug["entityState"] = { "id": entityStateId };
+        if (tags)
+            bug["Tags"] = tags;
+        if (teamIterationId)
+            bug["TeamIteration"] = { "Id": teamIterationId };
         return this.post({
             pathParam: ["bugs"],
             param: { "format": "json" },
         }, bug);
     }
-    async createBugOnly({ title, bugContent, origin = "Manual QA", projectId, teamId, entityStateId }) {
+    async createBugOnly({ title, bugContent, origin = "Manual QA", projectId, teamId, entityStateId, tags, teamIterationId }) {
         const bug = {
             "Name": title,
             "Project": {
@@ -293,12 +306,16 @@ export class TpClient {
         };
         if (entityStateId)
             bug["EntityState"] = { "Id": entityStateId };
+        if (tags)
+            bug["Tags"] = tags;
+        if (teamIterationId)
+            bug["TeamIteration"] = { "Id": teamIterationId };
         return this.post({
             pathParam: ["bugs"],
             param: { "format": "json" },
         }, bug);
     }
-    async createUserStory({ title, description, featureId, releaseId, projectId, teamId }) {
+    async createUserStory({ title, description, featureId, releaseId, projectId, teamId, tags, teamIterationId }) {
         const userStory = {
             "Name": title,
             "Project": { "Id": projectId || config.tp.projectId },
@@ -310,11 +327,25 @@ export class TpClient {
             userStory["Feature"] = { "Id": featureId };
         if (releaseId)
             userStory["Release"] = { "Id": releaseId };
+        if (tags)
+            userStory["Tags"] = tags;
+        if (teamIterationId)
+            userStory["TeamIteration"] = { "Id": teamIterationId };
         return this.post({
             pathParam: ["UserStories"],
             param: { "format": "json" },
         }, userStory);
     }
+    async getTeamIterations({ teamId } = {}) {
+        return this.get({
+            pathParam: ["TeamIterations"],
+            param: {
+                "format": "json",
+                ...(teamId ? { "where": `Team.Id eq ${teamId}` } : {}),
+                "include": "[Id,Name,StartDate,EndDate,Team[Id,Name]]",
+            },
+        });
+    }
     async getEpic(epicId) {
         return this.get({
             pathParam: ["Epics", epicId],
@@ -378,6 +409,31 @@ export class TpClient {
             param: { "format": "json" },
         }, feature);
     }
+    async updateFeature({ id, title, description, epicId, releaseId, projectId, teamId, entityStateId, tags, teamIterationId }) {
+        const feature = { "Id": id };
+        if (title)
+            feature["Name"] = title;
+        if (description)
+            feature["Description"] = description;
+        if (epicId)
+            feature["Epic"] = { "Id": epicId };
+        if (releaseId)
+            feature["Release"] = { "Id": releaseId };
+        if (projectId)
+            feature["Project"] = { "Id": projectId };
+        if (teamId)
+            feature["assignedTeams"] = [{ "team": { "id": teamId } }];
+        if (entityStateId)
+            feature["EntityState"] = { "Id": entityStateId };
+        if (tags)
+            feature["Tags"] = tags;
+        if (teamIterationId)
+            feature["TeamIteration"] = { "Id": teamIterationId };
+        return this.post({
+            pathParam: ["Features"],
+            param: { "format": "json" },
+        }, feature);
+    }
     async createBugBasedOnUserStory(title, userStoryId, bugContent) {
         const bug = {
             "Name": title,
@@ -798,6 +854,18 @@ export class TpClient {
             param: { "format": "json" },
         });
     }
+    async deleteCard({ id, type }) {
+        const pathSegment = {
+            "Bug": "bugs",
+            "UserStory": "userStories",
+            "Feature": "features",
+            "Epic": "Epics",
+        };
+        return this.del({
+            pathParam: [pathSegment[type], id],
+            param: { "format": "json" },
+        });
+    }
     async getProjects() {
         return this.get({
             pathParam: ["Projects"],
@@ -1106,7 +1174,7 @@ export class TpClient {
         formData.append("generalId", generalId);
         formData.append("file", blob, fileName);
         const url = `${this.baseUrl}/UploadFile.ashx?access_token=${this.token}`;
-        console.error(JSON.stringify({ "UPLOAD_URL": url.replace(this.token, "***") }, null, 2));
+        console.error(JSON.stringify({ "UPLOAD_URL": this.redact(url) }, null, 2));
         try {
             const response = await fetch(url, {
                 method: "POST",

package/package.json

@@ -27,7 +27,7 @@
   "engines": {
     "node": ">=20.x"
   },
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "MCP server for Tartget Process",
   "main": "build/index.js",
   "keywords": [