@sppg2001/atomize 1.0.1 → 1.0.3

package/dist/cli/index.js

@@ -98840,9 +98840,11 @@ class TemplateLoadError extends AtomizeError {
 
 class TemplateValidationError extends AtomizeError {
   errors;
-  constructor(message, errors) {
+  suggestions;
+  constructor(message, errors, suggestions) {
     super(AtomizeErrorCode.TemplateValidationError, message);
     this.errors = errors;
+    this.suggestions = suggestions;
   }
 }
 
@@ -98887,9 +98889,11 @@ class CancellationError extends AtomizeError {
 
 class CircularDependencyError extends Error {
   cycle;
-  constructor(message, cycle) {
+  suggestion;
+  constructor(message, cycle, suggestion) {
     super(message);
     this.cycle = cycle;
+    this.suggestion = suggestion;
     this.name = "CircularDependencyError";
   }
 }
@@ -99098,7 +99102,9 @@ class DependencyResolver {
     }
     if (visited.size !== graph.size) {
       const cycle = this.detectCycle(graph, visited);
-      throw new CircularDependencyError(`Circular dependency detected: ${cycle.join(" -> ")}`, cycle);
+      const cycleDisplay = cycle.join(" -> ");
+      const suggestion = `Break the circular dependency by removing one of these dependencies: ${cycle.map((id, i) => i < cycle.length - 1 ? `"${id}" depends on "${cycle[i + 1]}"` : "").filter(Boolean).join(", ")}`;
+      throw new CircularDependencyError(`Circular dependency detected: ${cycleDisplay}. ${suggestion}`, cycle);
     }
     return result;
   }
@@ -99149,11 +99155,13 @@ class DependencyResolver {
   validateDependencies(tasks) {
     const errors2 = [];
     const taskIds = new Set(tasks.map((t) => t.id).filter((id) => id));
+    const availableIds = Array.from(taskIds);
     for (const task of tasks) {
       if (task.dependsOn && task.dependsOn.length > 0) {
         for (const depId of task.dependsOn) {
           if (!taskIds.has(depId)) {
-            errors2.push(`Task "${task.title}" (ID: ${task.id}) depends on non-existent task ID: "${depId}"`);
+            const suggestion = availableIds.length > 0 ? ` Available task IDs: ${availableIds.map((id) => `"${id}"`).join(", ")}` : " Add an 'id' field to the task you want to depend on.";
+            errors2.push(`Task "${task.title}" (ID: ${task.id}) depends on non-existent task ID: "${depId}".${suggestion}`);
           }
         }
       }
@@ -99472,6 +99480,9 @@ class EstimationCalculator {
         priority: templateTask.priority,
         activity: templateTask.activity,
         remainingWork: templateTask.remainingWork,
+        completedWork: 0,
+        iteration: story.iteration,
+        areaPath: story.areaPath,
         customFields: templateTask.customFields,
         templateId: templateTask.id,
         estimationPercent: templateTask.estimationPercent
@@ -99511,6 +99522,9 @@ class EstimationCalculator {
         priority: templateTask.priority,
         activity: templateTask.activity,
         remainingWork: templateTask.remainingWork,
+        completedWork: 0,
+        iteration: story.iteration,
+        areaPath: story.areaPath,
         customFields: templateTask.customFields,
         templateId: templateTask.id,
         estimationPercent: templateTask.estimationPercent
@@ -99547,7 +99561,7 @@ class EstimationCalculator {
     return 0;
   }
   roundEstimation(value, strategy) {
-    return M(strategy).with("up", () => Math.ceil(value)).with("down", () => Math.floor(value)).with("nearest", () => Math.round(value)).otherwise(() => Math.floor(value * 100) / 100);
+    return M(strategy).with("up", () => Math.ceil(value * 2) / 2).with("down", () => Math.floor(value * 2) / 2).with("nearest", () => Math.round(value * 2) / 2).otherwise(() => Math.floor(value * 100) / 100);
   }
   interpolateTitle(title, story) {
     return title.replace(/\${story\.title}/g, story.title).replace(/\${story\.id}/g, story.id);
@@ -100057,6 +100071,27 @@ class AzureDevOpsAdapter {
             value: task.estimation
           }
         ] : [],
+        ...task.completedWork !== undefined ? [
+          {
+            op: "add",
+            path: "/fields/Microsoft.VSTS.Scheduling.CompletedWork",
+            value: task.completedWork
+          }
+        ] : [],
+        ...task.iteration ? [
+          {
+            op: "add",
+            path: "/fields/System.IterationPath",
+            value: task.iteration
+          }
+        ] : [],
+        ...task.areaPath ? [
+          {
+            op: "add",
+            path: "/fields/System.AreaPath",
+            value: task.areaPath
+          }
+        ] : [],
         ...task.tags && task.tags.length > 0 ? [
           {
             op: "add",
@@ -100249,6 +100284,11 @@ class AzureDevOpsAdapter {
       const tagConditions = filter2.tags.include.map((tag) => `[System.Tags] CONTAINS '${tag}'`);
       conditions.push(`(${tagConditions.join(" OR ")})`);
     }
+    if (filter2.tags?.exclude && filter2.tags.exclude.length > 0) {
+      for (const tag of filter2.tags.exclude) {
+        conditions.push(`[System.Tags] NOT CONTAINS '${tag}'`);
+      }
+    }
     if (filter2.areaPaths && filter2.areaPaths.length > 0) {
       const paths = filter2.areaPaths.map((p2) => `'${p2}'`).join(", ");
       conditions.push(`[System.AreaPath] IN (${paths})`);
@@ -114288,8 +114328,8 @@ var TaskDefinitionSchema = exports_external.object({
   id: exports_external.string().optional(),
   title: exports_external.string().min(1, "Task title is required"),
   description: exports_external.string().optional(),
-  estimationPercent: exports_external.number().min(0).max(100).optional(),
-  estimationFixed: exports_external.number().min(0).optional(),
+  estimationPercent: exports_external.number().min(0, "Estimation percentage cannot be negative").max(100, "Estimation percentage cannot exceed 100").optional(),
+  estimationFixed: exports_external.number().min(0, "Fixed estimation cannot be negative").optional(),
   estimationFormula: exports_external.string().optional(),
   tags: exports_external.array(exports_external.string()).optional(),
   condition: exports_external.string().optional(),
@@ -114360,13 +114400,15 @@ var TaskTemplateSchema = exports_external.object({
   const taskIds = new Set(tasks.map((t2) => t2.id).filter(Boolean));
   validateEstimationConstraints(v2, totalPercent, ctx);
   validateTaskConstraints(v2, tasks, ctx);
+  const availableIds = Array.from(taskIds);
   tasks.forEach((task, index) => {
     task.dependsOn?.forEach((depId) => {
       if (!taskIds.has(depId)) {
+        const suggestion = availableIds.length > 0 ? ` Available task IDs: ${availableIds.map((id) => `"${id}"`).join(", ")}` : "";
         ctx.addIssue({
           code: "custom",
           path: ["tasks", index, "dependsOn"],
-          message: `Task depends on non-existent task ID: "${depId}"`,
+          message: `Task depends on non-existent task ID: "${depId}".${suggestion}`,
           params: { code: "INVALID_DEPENDENCY" }
         });
       }
@@ -114375,18 +114417,20 @@ var TaskTemplateSchema = exports_external.object({
 });
 function validateTaskConstraints(v2, tasks, ctx) {
   if (v2?.minTasks !== undefined && tasks.length < v2.minTasks) {
+    const needed = v2.minTasks - tasks.length;
     ctx.addIssue({
       code: "custom",
       path: ["tasks"],
-      message: `Template has ${tasks.length} tasks, but minimum is ${v2.minTasks}`,
+      message: `Template has ${tasks.length} task(s), but minimum is ${v2.minTasks}. Add ${needed} more task(s).`,
       params: { code: "TOO_FEW_TASKS" }
     });
   }
   if (v2?.maxTasks !== undefined && tasks.length > v2.maxTasks) {
+    const excess = tasks.length - v2.maxTasks;
     ctx.addIssue({
       code: "custom",
       path: ["tasks"],
-      message: `Template has ${tasks.length} tasks, but maximum is ${v2.maxTasks}`,
+      message: `Template has ${tasks.length} task(s), but maximum is ${v2.maxTasks}. Remove ${excess} task(s) or increase maxTasks.`,
       params: { code: "TOO_MANY_TASKS" }
     });
   }
@@ -114394,20 +114438,23 @@ function validateTaskConstraints(v2, tasks, ctx) {
 function validateEstimationConstraints(v2, totalPercent, ctx) {
   if (v2?.totalEstimationMustBe !== undefined) {
     if (totalPercent !== v2.totalEstimationMustBe) {
+      const diff = v2.totalEstimationMustBe - totalPercent;
+      const hint = diff > 0 ? ` Add ${diff}% to existing tasks.` : ` Reduce tasks by ${Math.abs(diff)}%.`;
       ctx.addIssue({
         code: "custom",
         path: ["tasks"],
-        message: `Total estimation is ${totalPercent}%, but must be ${v2.totalEstimationMustBe}%`,
+        message: `Total estimation is ${totalPercent}%, but must be ${v2.totalEstimationMustBe}%.${hint}`,
         params: { code: "INVALID_TOTAL_ESTIMATION" }
       });
     }
   } else if (v2?.totalEstimationRange) {
     const { min, max } = v2.totalEstimationRange;
     if (totalPercent < min || totalPercent > max) {
+      const hint = totalPercent < min ? ` Increase by ${min - totalPercent}%.` : ` Reduce by ${totalPercent - max}%.`;
       ctx.addIssue({
         code: "custom",
         path: ["tasks"],
-        message: `Total estimation is ${totalPercent}%, but must be between ${min}% and ${max}%`,
+        message: `Total estimation is ${totalPercent}%, but must be between ${min}% and ${max}%.${hint}`,
         params: { code: "INVALID_ESTIMATION_RANGE" }
       });
     }
@@ -114428,9 +114475,12 @@ class TemplateValidator {
     const total = template.tasks.reduce((sum, t2) => sum + (t2.estimationPercent ?? 0), 0);
     const hasStrictRule = v2?.totalEstimationMustBe !== undefined || v2?.totalEstimationRange !== undefined;
     if (!hasStrictRule && total !== 100) {
+      const diff = 100 - total;
+      const suggestion = diff > 0 ? `Add ${diff}% to existing tasks or create a new task with ${diff}% estimation.` : `Reduce task estimations by ${Math.abs(diff)}% to reach 100%.`;
       warnings.push({
         path: "tasks",
-        message: `Total estimation is ${total}% (expected 100%).`
+        message: `Total estimation is ${total}% (expected 100%).`,
+        suggestion
       });
     }
     this.validateTaskConditions(template, warnings);
@@ -114445,7 +114495,8 @@ class TemplateValidator {
         if (!hasVariable && !hasOperator) {
           warnings.push({
             path: `tasks[${index}].condition`,
-            message: `Condition "${task.condition}" might be invalid (no variables found)`
+            message: `Condition "${task.condition}" might be invalid (no variables found)`,
+            suggestion: `Use variables like \${story.tags} or operators like CONTAINS, ==, !=. Example: "\${story.tags} CONTAINS 'backend'"`
           });
         }
       }
@@ -114456,32 +114507,110 @@ class TemplateValidator {
       if (task.dependsOn && task.dependsOn.length > 0 && !task.id) {
         warnings.push({
           path: `tasks[${index}]`,
-          message: `Task "${task.title}" has dependencies but no id field. Add an id to enable dependency linking.`
+          message: `Task "${task.title}" has dependencies but no id field. Add an id to enable dependency linking.`,
+          suggestion: `Add an 'id' field to this task, e.g., 'id: "${this.generateIdFromTitle(task.title)}"'`
         });
       }
       if (!task.id) {
-        const isReferenced = template.tasks.some((t2) => t2.dependsOn?.includes(task.title));
-        if (isReferenced) {
+        const referencingTasks = template.tasks.filter((t2) => t2.dependsOn?.includes(task.title));
+        if (referencingTasks.length > 0) {
+          const taskNames = referencingTasks.map((t2) => `"${t2.title}"`).join(", ");
           warnings.push({
             path: `tasks[${index}]`,
-            message: `Task "${task.title}" is referenced by other tasks but has no id field.`
+            message: `Task "${task.title}" is referenced by other tasks but has no id field.`,
+            suggestion: `Add 'id: "${this.generateIdFromTitle(task.title)}"' to this task. Referenced by: ${taskNames}`
           });
         }
       }
     });
   }
+  generateIdFromTitle(title) {
+    return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").substring(0, 30);
+  }
   convertZodErrors(zodError) {
-    return zodError.issues.map((err) => ({
-      path: err.path.join("."),
-      message: err.message,
-      code: err.params?.code || err.code
-    }));
+    return zodError.issues.map((err) => {
+      const code = err.code === "custom" && typeof err.params?.code === "string" ? err.params.code : err.code;
+      return {
+        path: err.path.join("."),
+        message: err.message,
+        code,
+        suggestion: this.getSuggestionForError(err, code)
+      };
+    });
+  }
+  getSuggestionForError(err, code) {
+    const domainSuggestion = this.handleDomainError(err, code);
+    if (domainSuggestion)
+      return domainSuggestion;
+    return this.handleZodError(err);
+  }
+  handleDomainError(err, code) {
+    switch (code) {
+      case "INVALID_TOTAL_ESTIMATION":
+        return this.handleNumericError(err.message, /is (\d+)%, but must be (\d+)%/, (current, required2) => {
+          const diff = required2 - current;
+          return diff > 0 ? `Add ${diff}% to existing tasks or create a new task with ${diff}% estimation.` : `Reduce task estimations by ${Math.abs(diff)}% to reach ${required2}%.`;
+        });
+      case "INVALID_ESTIMATION_RANGE":
+        return this.handleNumericError(err.message, /is (\d+)%, but must be between (\d+)% and (\d+)%/, (current, min, max) => {
+          if (current < min)
+            return `Increase task estimations by ${min - current}% to meet the minimum of ${min}%.`;
+          return `Reduce task estimations by ${current - max}% to stay within the maximum of ${max}%.`;
+        });
+      case "TOO_FEW_TASKS":
+        return this.handleNumericError(err.message, /has (\d+) tasks?, but minimum is (\d+)/, (current, required2) => `Add ${required2 - current} more task(s) to meet the minimum requirement of ${required2} tasks.`);
+      case "TOO_MANY_TASKS":
+        return this.handleNumericError(err.message, /has (\d+) tasks?, but maximum is (\d+)/, (current, max) => `Remove ${current - max} task(s) or increase the maxTasks limit to ${current}.`);
+      case "INVALID_DEPENDENCY": {
+        const match = err.message.match(/non-existent task ID: "([^"]+)"/);
+        return match ? `Either add a task with id: "${match[1]}" or update the dependsOn field to reference an existing task ID.` : undefined;
+      }
+      default:
+        return;
+    }
+  }
+  handleNumericError(message, regex2, formatter) {
+    const values = this.extractValues(message, regex2);
+    if (!values || values.length === 0)
+      return;
+    return formatter(...values);
+  }
+  handleZodError(err) {
+    const { code, path: path2, expected, validation } = err;
+    if (code === "too_small") {
+      if (path2.includes("tasks"))
+        return "Add at least one task to the template.";
+      if (err.minimum === 1)
+        return "This field cannot be empty. Please provide a value.";
+      if (path2.includes("estimationPercent"))
+        return "Estimation percentage cannot be negative. Use a value between 0 and 100.";
+    }
+    if (code === "too_big" && path2.includes("estimationPercent")) {
+      return "Estimation percentage must be between 0 and 100. Current value exceeds 100%.";
+    }
+    if (code === "invalid_type") {
+      if (expected === "string")
+        return `Expected a text value but received ${err.received}. Wrap the value in quotes.`;
+      if (expected === "number")
+        return `Expected a number but received ${err.received}. Remove quotes from numeric values.`;
+    }
+    if (code === "invalid_string" && validation === "email") {
+      return 'Use a valid email address format (e.g., user@example.com) or the special value "@Me".';
+    }
+    return;
+  }
+  extractValues(message, pattern) {
+    const match = message.match(pattern);
+    if (!match)
+      return [];
+    return match.slice(1).map((val) => parseInt(val, 10));
   }
   validateOrThrow(template) {
     const result = this.validate(template);
     if (!result.valid) {
       const errorMessages = result.errors.map((e2) => `${e2.path}: ${e2.message}`);
-      throw new TemplateValidationError("Template validation failed", errorMessages);
+      const suggestions = result.errors.map((e2) => e2.suggestion).filter((s2) => s2 !== undefined);
+      throw new TemplateValidationError("Template validation failed", errorMessages, suggestions.length > 0 ? suggestions : undefined);
     }
     return template;
   }
@@ -114497,6 +114626,9 @@ class TemplateValidator {
       lines.push("Errors:");
       result.errors.forEach((err) => {
         lines.push(` - ${err.path}: ${err.message}`);
+        if (err.suggestion) {
+          lines.push(`   \uD83D\uDCA1 ${err.suggestion}`);
+        }
       });
       lines.push("");
     }
@@ -114504,6 +114636,9 @@ class TemplateValidator {
       lines.push("Warnings:");
       result.warnings.forEach((warn) => {
         lines.push(`${warn.path}: ${warn.message}`);
+        if (warn.suggestion) {
+          lines.push(`   \uD83D\uDCA1 ${warn.suggestion}`);
+        }
       });
     }
     return lines.join(`
@@ -117831,6 +117966,9 @@ async function createFromScratch(_options = {}) {
     console.log(source_default.gray(`Tip: Choose a clear, descriptive name for your template
 `));
     const basicInfo = await configureBasicInfo();
+    if (!basicInfo.name || basicInfo.name.trim() === "") {
+      throw new ConfigurationError("Template name is required");
+    }
     const { confirmStep1 } = await dist_default12.prompt([
       {
         type: "confirm",
@@ -117840,7 +117978,7 @@ async function createFromScratch(_options = {}) {
       }
     ]);
     if (!confirmStep1) {
-      throw new Error("Template creation cancelled by user");
+      throw new CancellationError("Template creation cancelled by user");
     }
     currentStep++;
     console.log(source_default.blue(`
@@ -117849,9 +117987,10 @@ async function createFromScratch(_options = {}) {
     console.log(source_default.gray(`Tip: Use filters to select which work items this template applies to
 `));
     const filterConfig = await configureFilter();
-    if ((!filterConfig.workItemTypes || filterConfig.workItemTypes.length === 0) && (!filterConfig.states || filterConfig.states.length === 0)) {
+    if ((!filterConfig.workItemTypes || filterConfig.workItemTypes.length === 0) && (!filterConfig.states || filterConfig.states.length === 0) && !filterConfig.customQuery) {
       console.log(source_default.yellow(`
-⚠ Warning: No work item types or states selected. Template will match all items.`));
+ Warning: No work item types, states, or custom query configured.`));
+      console.log(source_default.yellow("   This template will match ALL work items."));
       const { continueAnyway } = await dist_default12.prompt([
         {
           type: "confirm",
@@ -117861,10 +118000,7 @@ async function createFromScratch(_options = {}) {
         }
       ]);
       if (!continueAnyway) {
-        console.log(source_default.gray(`
-Returning to filter configuration...
-`));
-        throw new Error("Please configure at least work item types or states");
+        throw new CancellationError("Template creation cancelled. Please configure filter criteria.");
       }
     }
     const { confirmStep2 } = await dist_default12.prompt([
@@ -117876,15 +118012,21 @@ Returning to filter configuration...
       }
     ]);
     if (!confirmStep2) {
-      throw new Error("Template creation cancelled by user");
+      throw new CancellationError("Template creation cancelled by user");
     }
     currentStep++;
     console.log(source_default.blue(`
 [${currentStep}/${totalSteps}] Task Configuration`));
     console.log(source_default.gray("███░░░"));
+    console.log(source_default.gray(`Tip: Break work into clear, actionable tasks
+`));
     const tasks = await configureTasksWithValidation();
-    if (tasks.length === 0) {
-      throw new Error("At least one task is required");
+    if (!tasks || tasks.length === 0) {
+      throw new ConfigurationError("At least one task is required. Please add tasks to your template.");
+    }
+    const invalidTasks = tasks.filter((task) => !task.title || task.title.trim() === "");
+    if (invalidTasks.length > 0) {
+      throw new ConfigurationError(`${invalidTasks.length} task(s) are missing titles. All tasks must have a title.`);
     }
     const { confirmStep3 } = await dist_default12.prompt([
       {
@@ -117895,13 +118037,13 @@ Returning to filter configuration...
       }
     ]);
     if (!confirmStep3) {
-      throw new Error("Template creation cancelled by user");
+      throw new CancellationError("Template creation cancelled by user");
     }
     currentStep++;
     console.log(source_default.blue(`
 [${currentStep}/${totalSteps}] Estimation Settings`));
     console.log(source_default.gray("████░░"));
-    console.log(source_default.gray(`\uD83D\uDCA1 Tip: Choose how story points will be calculated and rounded
+    console.log(source_default.gray(`Tip: Choose how story points will be calculated and rounded
 `));
     const estimation = await configureEstimation();
     const { confirmStep4 } = await dist_default12.prompt([
@@ -117913,7 +118055,7 @@ Returning to filter configuration...
       }
     ]);
     if (!confirmStep4) {
-      throw new Error("Template creation cancelled by user");
+      throw new CancellationError("Template creation cancelled by user");
     }
     currentStep++;
     console.log(source_default.blue(`
@@ -117948,7 +118090,7 @@ Returning to filter configuration...
     console.log(source_default.blue(`
 [${currentStep}/${totalSteps}] Metadata (Optional)`));
     console.log(source_default.gray("██████"));
-    console.log(source_default.gray(`Tip: Metadata helps others understand when to use this template
+    console.log(source_default.gray(`\uD83D\uDCA1 Tip: Metadata helps others understand when to use this template
 `));
     const { addMetadata } = await dist_default12.prompt([
       {
@@ -117976,23 +118118,44 @@ Returning to filter configuration...
       metadata
     };
     console.log(source_default.green(`
-✓ Template created successfully!
+✓ Template configured successfully!
+`));
+    console.log(source_default.gray(`Review your template and choose an action below.
 `));
     const confirmed = await previewTemplate(template);
     if (!confirmed) {
       console.log(source_default.yellow(`
- Template creation cancelled. No changes were saved.`));
+⚠  Template creation cancelled. No changes were saved.`));
       throw new CancellationError("Template creation cancelled by user");
     }
+    console.log(source_default.cyan(`
+\uD83D\uDCCB Final confirmation before saving...
+`));
+    const { finalConfirm } = await dist_default12.prompt([
+      {
+        type: "confirm",
+        name: "finalConfirm",
+        message: "Save this template?",
+        default: true
+      }
+    ]);
+    if (!finalConfirm) {
+      throw new CancellationError("Template save cancelled by user");
+    }
     return template;
   } catch (error48) {
     if (error48 instanceof CancellationError) {
       console.log(source_default.yellow(`
-⚠ Template creation cancelled`));
-    } else {
+ Template creation cancelled`));
+      throw error48;
+    }
+    if (error48 instanceof ConfigurationError) {
       console.log(source_default.red(`
-✗ Error creating template: ${error48.message}`));
+ Configuration error: ${error48.message}`));
+      console.log(source_default.gray("  Please check your inputs and try again."));
+      throw error48;
     }
+    console.log(source_default.red(` Error creating template: ${error48.message}`));
     throw error48;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sppg2001/atomize",
-	"version": "1.0.1",
+	"version": "1.0.3",
 	"description": "Automatically generate tasks from user stories with smart templates",
 	"type": "module",
 	"main": "./dist/cli/index.js",
@@ -29,7 +29,7 @@
 		"prepublishOnly": "npm run build",
 		"test": "bun test",
 		"test:unit": "bun test tests/unit",
-		"test:integration": "bun test tests/integration.test.ts",
+		"test:integration": "bun test tests/integration",
 		"test:watch": "bun test --watch",
 		"test:coverage": "bun test --coverage --coverage-reporter=lcov",
 		"typecheck": "tsc --noEmit",

package/templates/presets/custom.yaml

@@ -6,81 +6,111 @@ tags: []
 
 filter:
   workItemTypes: ["User Story"]
-  states: ["New"]
-  tags:
-    include: ["Candidate S113"]
-  excludeIfHasTasks: true
+  states: ["Ready for Sprint"]
+  tags:   
+    exclude: 
+      - "Test Only"
+      - "TestGen"
+
+
+  excludeIfHasTasks: false
+  areaPaths:
+    - EA-RSP-Platform\Release 2 Team
+  iterations:
+    - EA-RSP-Platform\SOW-7-2026-JAN-MARCH\Sprint 115
+  
 
 tasks:
   - title: "Analysis & Playback"
-    description: "Analyze requirements and planning of necessary changes and discuss with the team."
     estimationPercent: 20
     activity: "Development"
     tags: []
+    assignTo: "@ParentAssignee"
+
+
 
   - title: "Build"
-    description: "Devolop the required changes in the codebase following best practices."
     estimationPercent: 50
     activity: "Development"
     tags: []
+    assignTo: "@ParentAssignee"
+
 
   - title: "Developer Test"
-    description: "Testing the changes made to ensure they meet the requirements and do not introduce new issues.Provide evidence of testing"
     estimationPercent: 25
     activity: "Development"
     tags: []
+    assignTo: "@ParentAssignee"
+
 
   - title: "QA Smoke Test"
-    description: "Ensure that main functionalities are working as expected after the deployment to the QA environment."
     estimationPercent: 0
     activity: "Development"
     tags: []
+    assignTo: "@ParentAssignee"
+
 
-  - title: "WIKI"
-    description: "Update relevant documentation and WIKI pages to reflect the changes made."
+  - title: "Wiki"
     estimationPercent: 5
     activity: "Development"
     tags: []
+    assignTo: "@ParentAssignee"
+
 
   - title: "Code Review "
-    description: "Address code review feedback and refactor as needed"
     estimationPercent: 0
     activity: "Development"
     tags: []
+    assignTo: "@Unassigned"
   
   - title: "Test Preparation"
-    description: "Prepare test cases and scenarios for QA testing."
     estimationPercent: 40
     activity: "Testing"
     tags: []
+    condition: '${story.tags} NOT CONTAINS "Dev Only"'
+    assignTo: "@Unassigned"
+
+
   
   - title: "Test Execution"
-    description: "Execute test cases and report any defects found during testing."
     estimationPercent: 27
     activity: "Testing"
     tags: []
+    condition: '${story.tags} NOT CONTAINS "Dev Only"'
+    assignTo: "@Unassigned"
+
+
 
   - title: "Automation Testing"
-    description: "Develop and maintain automated test scripts to improve testing efficiency."
     estimationPercent: 0
     activity: "Testing"
     tags: []
+    condition: '${story.tags} NOT CONTAINS "Dev Only"'
+    assignTo: "@Unassigned"
+
+
   
   - title: "Test Review"
-    description: "Review test results and ensure all requirements are met before deployment."
     estimationPercent: 0
     activity: "Testing"
     tags: []
+    condition: '${story.tags} NOT CONTAINS "Dev Only"'
+    assignTo: "@Unassigned"
+
+
   
   - title: "Release Notes"
-    description: "Prepare release notes and documentation for the deployment."
     estimationPercent: 0
-    activity: "Documentation"
+    activity: "Testing"
     tags: []
+    condition: '${story.tags} NOT CONTAINS "Dev Only"'
+    assignTo: "@Unassigned"
+
+
 
 estimation:
   strategy: "percentage"
-  rounding: "nearest"
+  rounding: "none"
   minimumTaskPoints: 0
 
 metadata: