@sppg2001/atomize 4.1.0 → 4.2.0

package/dist/cli/index.js

@@ -178,6 +178,11 @@ var init_errors = __esm(() => {
   };
 });
 
+// ../atomize-schema/src/estimate-format.ts
+function formatEstimateValue(value) {
+  return String(Math.round(value * 100) / 100);
+}
+
 // ../atomize-schema/src/estimation-fields.ts
 function matchesFieldPattern(referenceName, patterns = []) {
   return patterns.some((pattern) => pattern.endsWith(".*") ? referenceName.startsWith(pattern.slice(0, -1)) : referenceName === pattern);
@@ -20112,23 +20117,63 @@ function ownPercentRange(task) {
   const candidates = [task.estimationPercent ?? 0, ...task.estimationPercentCondition?.map((rule) => rule.percent) ?? []];
   return [Math.min(...candidates), Math.max(...candidates)];
 }
+function copyCount(task) {
+  return task.repeat ?? 1;
+}
+function generatedTaskCount(tasks) {
+  return tasks.reduce((sum, task) => sum + copyCount(task), 0);
+}
+function validateRepeatedTasks(tasks, ctx, maxRepeat) {
+  const repeatedIds = new Set(tasks.filter((t) => t.repeat !== undefined && t.id).map((t) => t.id));
+  tasks.forEach((task, index) => {
+    if (maxRepeat !== undefined && task.repeat !== undefined && task.repeat > maxRepeat) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["tasks", index, "repeat"],
+        message: `Task repeats ${task.repeat} times, but the maximum is ${maxRepeat}. Lower repeat or raise validation.maxRepeat.`,
+        params: { code: "REPEAT_EXCEEDS_MAX", maxRepeat }
+      });
+    }
+    if (task.repeat !== undefined && task.dependsOn?.length) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["tasks", index, "dependsOn"],
+        message: "A repeated task cannot have dependsOn. Remove repeat or dependsOn from this task.",
+        params: { code: "REPEAT_WITH_DEPENDENCY" }
+      });
+    }
+    task.dependsOn?.forEach((depId) => {
+      if (repeatedIds.has(depId)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["tasks", index, "dependsOn"],
+          message: `Task depends on "${depId}", which is repeated. A task cannot depend on a repeated task.`,
+          params: { code: "DEPENDS_ON_REPEATED_TASK", taskId: depId }
+        });
+      }
+    });
+  });
+}
 function validateTaskConstraints(v, tasks, ctx) {
-  if (v?.minTasks !== undefined && tasks.length < v.minTasks) {
-    const needed = v.minTasks - tasks.length;
+  const count = generatedTaskCount(tasks);
+  const hasRepeats = tasks.some((task) => copyCount(task) > 1);
+  const counted = hasRepeats ? " (counting each repeated copy)" : "";
+  if (v?.minTasks !== undefined && count < v.minTasks) {
+    const needed = v.minTasks - count;
     ctx.addIssue({
       code: "custom",
       path: ["tasks"],
-      message: `Template has ${tasks.length} task(s), but minimum is ${v.minTasks}. Add ${needed} more task(s).`,
-      params: { code: "TOO_FEW_TASKS" }
+      message: `Template has ${count} task(s)${counted}, but minimum is ${v.minTasks}. Add ${needed} more task(s).`,
+      params: { code: "TOO_FEW_TASKS", count, limit: v.minTasks, hasRepeats }
     });
   }
-  if (v?.maxTasks !== undefined && tasks.length > v.maxTasks) {
-    const excess = tasks.length - v.maxTasks;
+  if (v?.maxTasks !== undefined && count > v.maxTasks) {
+    const excess = count - v.maxTasks;
     ctx.addIssue({
       code: "custom",
       path: ["tasks"],
-      message: `Template has ${tasks.length} task(s), but maximum is ${v.maxTasks}. Remove ${excess} task(s) or increase maxTasks.`,
-      params: { code: "TOO_MANY_TASKS" }
+      message: `Template has ${count} task(s)${counted}, but maximum is ${v.maxTasks}. Remove ${excess} task(s) or increase maxTasks.`,
+      params: { code: "TOO_MANY_TASKS", count, limit: v.maxTasks, hasRepeats }
     });
   }
 }
@@ -20150,14 +20195,14 @@ function validateUniqueTaskIds(tasks, ctx) {
     });
   });
 }
-function validateEstimationConstraints(v, totalPercent, maxTotalPercent, ctx) {
+function validateEstimationConstraints(v, totalPercent, maxTotalPercent, hasRepeats, ctx) {
   if (v?.totalEstimationMustBe !== undefined) {
     if (v.totalEstimationMustBe < totalPercent || v.totalEstimationMustBe > maxTotalPercent) {
       ctx.addIssue({
         code: "custom",
         path: ["tasks"],
         message: `Total estimation is ${totalPercent}%, but must be ${v.totalEstimationMustBe}%.`,
-        params: { code: "INVALID_TOTAL_ESTIMATION" }
+        params: { code: "INVALID_TOTAL_ESTIMATION", hasRepeats }
       });
     }
   } else if (v?.totalEstimationRange) {
@@ -20167,7 +20212,7 @@ function validateEstimationConstraints(v, totalPercent, maxTotalPercent, ctx) {
         code: "custom",
         path: ["tasks"],
         message: `Total estimation is ${totalPercent}%, but must be between ${min}% and ${max}%.`,
-        params: { code: "INVALID_ESTIMATION_RANGE" }
+        params: { code: "INVALID_ESTIMATION_RANGE", hasRepeats }
       });
     }
   }
@@ -20205,7 +20250,7 @@ function reportCircularDependencies(tasks, taskIndexById, ctx) {
     });
   }
 }
-var DATE_OR_MACRO_RE, DateOrMacroSchema, REFERENCE_NAME_RE, ConditionOperatorSchema, ConditionValueSchema, MULTI_VALUE_STANDARD_FIELDS, MULTI_VALUE_FIELD_OPERATORS, ConditionSchema, SavedQuerySchema, FilterCriteriaSchema, EstimationPercentConditionSchema, TaskDefinitionSchema, NUMBER_PATTERN, EstimationConversionSchema, EstimationConfigSchema, ValidationModeSchema, ValidationConfigSchema, MetadataSchema, TaskTemplateBaseSchema, ExtendingTaskTemplateSchema, TaskTemplateSchema, MixinTemplateSchema, CURRENT_ITERATION = "@CurrentIteration", TEAM_AREAS = "@TeamAreas";
+var DATE_OR_MACRO_RE, DateOrMacroSchema, REFERENCE_NAME_RE, ConditionOperatorSchema, ConditionValueSchema, MULTI_VALUE_STANDARD_FIELDS, MULTI_VALUE_FIELD_OPERATORS, ConditionSchema, SavedQuerySchema, FilterCriteriaSchema, EstimationPercentConditionSchema, TaskDefinitionSchema, NUMBER_PATTERN, EstimationConversionSchema, EstimationConfigSchema, ValidationModeSchema, ValidationConfigSchema, MetadataSchema, TaskTemplateBaseSchema, ExtendingTaskTemplateSchema, TaskTemplateSchema, DEFAULT_MAX_REPEAT = 20, MixinTemplateSchema, CURRENT_ITERATION = "@CurrentIteration", TEAM_AREAS = "@TeamAreas";
 var init_schema = __esm(() => {
   init_zod();
   DATE_OR_MACRO_RE = /^(@Today|@StartOfDay|@StartOfMonth|@StartOfWeek|@StartOfYear)(\s*[+-]\s*\d+)?$|^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/i;
@@ -20299,6 +20344,7 @@ var init_schema = __esm(() => {
     tags: exports_external.array(exports_external.string()).describe("Tags applied to the generated task.").optional(),
     condition: ConditionSchema.describe("Condition evaluated against the parent story. If it does not match, this task is skipped.").optional(),
     dependsOn: exports_external.array(exports_external.string()).describe("IDs of tasks this task depends on. Atomize creates predecessor dependency links between these tasks.").optional(),
+    repeat: exports_external.number().int("Repeat count must be a whole number").min(1, "Repeat count must be at least 1").describe("Number of identical Tasks to generate from this definition (default 1). Each copy's title gets its position, e.g. 'Review (2)'. Cannot be combined with dependsOn.").optional(),
     assignTo: exports_external.string().describe("Email address or alias to assign this task to.").optional(),
     priority: exports_external.number().describe("Priority value for the generated task.").optional(),
     activity: exports_external.string().describe("Azure DevOps activity type for this task (e.g. 'Development', 'Testing', 'Design').").optional(),
@@ -20365,6 +20411,7 @@ var init_schema = __esm(() => {
     }).strict().describe("Sum of all non-conditional task percentages must fall within this range; bounds may exceed 100 when tasks span roles.").optional(),
     minTasks: exports_external.number().describe("Minimum number of tasks the template must define.").optional(),
     maxTasks: exports_external.number().describe("Maximum number of tasks the template may define.").optional(),
+    maxRepeat: exports_external.number().int("Maximum repeat count must be a whole number").min(1, "Maximum repeat count must be at least 1").describe("Highest 'repeat' any task in this template may use (default 20). Raise it for a template that genuinely needs more copies.").optional(),
     taskEstimationRange: exports_external.object({
       min: exports_external.number().describe("Minimum allowed estimation percentage for a single task."),
       max: exports_external.number().describe("Maximum allowed estimation percentage for a single task.")
@@ -20419,12 +20466,13 @@ var init_schema = __esm(() => {
     let maxTotalPercent = 0;
     for (const task of tasks) {
       const [ownMin, ownMax] = ownPercentRange(task);
-      totalPercent += task.condition ? 0 : ownMin;
-      maxTotalPercent += ownMax;
+      const copies = copyCount(task);
+      totalPercent += task.condition ? 0 : ownMin * copies;
+      maxTotalPercent += ownMax * copies;
     }
     const taskIds = new Set(tasks.map((t) => t.id).filter(Boolean));
     validateUniqueTaskIds(tasks, ctx);
-    validateEstimationConstraints(v, totalPercent, maxTotalPercent, ctx);
+    validateEstimationConstraints(v, totalPercent, maxTotalPercent, tasks.some((t) => copyCount(t) > 1), ctx);
     validateTaskConstraints(v, tasks, ctx);
     validateRequiredTasks(v, tasks, ctx);
     const availableIds = Array.from(taskIds);
@@ -20433,6 +20481,7 @@ var init_schema = __esm(() => {
       if (t.id)
         taskIndexById.set(t.id, i);
     });
+    validateRepeatedTasks(tasks, ctx, v?.maxRepeat ?? DEFAULT_MAX_REPEAT);
     tasks.forEach((task, index) => {
       task.dependsOn?.forEach((depId) => {
         if (!taskIds.has(depId)) {
@@ -20455,6 +20504,7 @@ var init_schema = __esm(() => {
     origin: exports_external.string().describe("Catalog ref (template:<name> or mixin:<name>) this mixin was derived from. Informational only — does not affect ref resolution.").optional()
   }).strict().superRefine((data, ctx) => {
     validateUniqueTaskIds(data.tasks, ctx);
+    validateRepeatedTasks(data.tasks, ctx);
   });
 });
 
@@ -21270,16 +21320,32 @@ function totalEstimationPercent(tasks) {
   return tasks.reduce((sum, task) => sum + (task.estimationPercent ?? 0), 0);
 }
 function totalUnconditionalEstimationPercent(tasks) {
-  return tasks.filter((task) => !task.condition).reduce((sum, task) => sum + (task.estimationPercent ?? 0), 0);
+  return tasks.filter((task) => !task.condition).reduce((sum, task) => sum + (task.estimationPercent ?? 0) * copyCount(task), 0);
 }
 function shouldOfferOverageNormalization(tasks) {
   const total = totalEstimationPercent(tasks);
   return { shouldOffer: total > 100, total };
 }
 var init_estimation_distribution = __esm(() => {
+  init_schema2();
   init_estimation_normalizer();
 });
 
+// ../atomize-core/src/core/task-repeater.ts
+function repeatTasks(tasks) {
+  return tasks.flatMap((task) => {
+    const iterationCount = task.repeat ?? 1;
+    return Array.from({ length: iterationCount }, (_2, index) => ({
+      task,
+      iteration: index + 1,
+      iterationCount
+    }));
+  });
+}
+function withOrdinal(title, { iteration, iterationCount }) {
+  return iterationCount > 1 ? `${title} (${iteration})` : title;
+}
+
 // ../atomize-core/src/core/template-interpolator.ts
 function interpolateValue(template, story, onMissing) {
   return template.replace(/\${story\.title}/g, story.title).replace(/\${story\.id}/g, story.id).replace(/\${story\.description}/g, story.description ?? "").replace(/\{\{\s*story\.customFields\['([^']+)'\]\s*\}\}/g, (_match, referenceName) => {
@@ -21314,8 +21380,9 @@ class EstimationCalculator {
     if (resolution.kind === "blank") {
       logger.warn(`Story ${story.id}: ${resolution.reason}. Task Estimates will be left blank.`);
     }
-    const calculatedTasks = [];
     const skippedTasks = [];
+    const activeTasks = [];
+    const resolvedPercents = new Map;
     for (const templateTask of templateTasks) {
       logger.debug(`Processing template task: ${templateTask.title} (Condition: ${templateTask.condition ? JSON.stringify(templateTask.condition) : "none"})`);
       if (templateTask.condition) {
@@ -21345,9 +21412,14 @@ class EstimationCalculator {
         skippedTasks.push({ templateTask, reason });
         continue;
       }
-      const calculatedTask = this.buildCalculatedTask(templateTask, story, connectUserEmail, 0, resolvedPercent);
-      calculatedTasks.push(calculatedTask);
+      activeTasks.push(templateTask);
+      resolvedPercents.set(templateTask, resolvedPercent);
     }
+    const calculatedTasks = repeatTasks(activeTasks).map((copy) => {
+      const calculatedTask = this.buildCalculatedTask(copy.task, story, connectUserEmail, 0, resolvedPercents.get(copy.task));
+      calculatedTask.title = withOrdinal(calculatedTask.title, copy);
+      return calculatedTask;
+    });
     if (fieldMapping) {
       for (const task of calculatedTasks) {
         task.workItemType = fieldMapping.taskWorkItemType;
@@ -89478,7 +89550,7 @@ class TemplateValidator {
   collectWarnings(template) {
     const warnings = [];
     const v2 = template.validation;
-    const total = template.tasks.reduce((sum, t2) => sum + (t2.estimationPercent ?? 0), 0);
+    const total = template.tasks.reduce((sum, t2) => sum + (t2.estimationPercent ?? 0) * copyCount(t2), 0);
     const hasStrictRule = v2?.totalEstimationMustBe !== undefined || v2?.totalEstimationRange !== undefined;
     const normalize = template.estimation?.normalize ?? "auto";
     if (!hasStrictRule && total > 100 && normalize !== "always") {
@@ -89604,22 +89676,32 @@ class TemplateValidator {
     return this.handleZodError(err);
   }
   handleDomainError(err, code) {
+    const params = err.code === "custom" ? err.params : undefined;
+    const repeatHint = params?.hasRepeats ? " Each copy of a repeated task counts toward this total." : "";
     switch (code) {
       case "INVALID_TOTAL_ESTIMATION":
-        return this.handleNumericError(err.message, /is (\d+)%, but must be (\d+)%/, (current, required2) => {
+        return this.withHint(repeatHint, 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) => {
+        return this.withHint(repeatHint, 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 "TOO_FEW_TASKS": {
+        if (typeof params?.count !== "number" || typeof params.limit !== "number")
+          return;
+        const { count, limit } = params;
+        return params.hasRepeats ? `Add ${limit - count} more task(s) or raise a repeat count to meet the minimum requirement of ${limit} tasks.` : `Add ${limit - count} more task(s) to meet the minimum requirement of ${limit} tasks.`;
+      }
+      case "TOO_MANY_TASKS": {
+        if (typeof params?.count !== "number" || typeof params.limit !== "number")
+          return;
+        const { count, limit } = params;
+        return params.hasRepeats ? `Remove ${count - limit} task(s), lower a repeat count, or increase the maxTasks limit to ${count}.` : `Remove ${count - limit} task(s) or increase the maxTasks limit to ${count}.`;
+      }
       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;
@@ -89632,6 +89714,14 @@ class TemplateValidator {
         }
         return "Remove one of the dependencies in the cycle to break the circular reference.";
       }
+      case "REPEAT_EXCEEDS_MAX":
+        return "Lower the repeat count, or raise validation.maxRepeat if the template genuinely needs more copies.";
+      case "REPEAT_WITH_DEPENDENCY":
+        return "Remove dependsOn from the repeated task, or remove repeat and define each copy as its own task.";
+      case "DEPENDS_ON_REPEATED_TASK": {
+        const match = err.message.match(/depends on "([^"]+)"/);
+        return match ? `Remove "${match[1]}" from dependsOn, or remove repeat from task "${match[1]}".` : "Remove the dependency on the repeated task, or remove its repeat.";
+      }
       case "MISSING_REQUIRED_TASK": {
         const match = err.message.match(/title "([^"]+)"/);
         return match ? `Add a task with title "${match[1]}" to satisfy the required tasks constraint.` : "Add the missing required task to the template.";
@@ -89640,6 +89730,9 @@ class TemplateValidator {
         return;
     }
   }
+  withHint(hint, suggestion) {
+    return suggestion && `${suggestion}${hint}`;
+  }
   handleNumericError(message, regex, formatter) {
     const values = this.extractValues(message, regex);
     if (!values || values.length === 0)
@@ -93384,6 +93477,12 @@ var init_prompt_utilities = __esm(() => {
         return required2;
       return Validators.maxLength(fieldName, maxLength)(input2);
     },
+    positiveInteger: (fieldName) => (input2) => {
+      const num = Number(input2);
+      if (!input2 || input2.trim() === "" || !Number.isInteger(num) || num < 1)
+        return `${fieldName} must be a whole number of at least 1`;
+      return;
+    },
     positiveNumber: (fieldName) => (input2) => {
       const num = Number(input2);
       if (!input2 || input2.trim() === "" || Number.isNaN(num))
@@ -98679,7 +98778,7 @@ var program = new Command;
 
 // package.json
 var name = "@sppg2001/atomize";
-var version2 = "4.1.0";
+var version2 = "4.2.0";
 
 // src/cli/commands/auth/auth-add.command.ts
 init_dist6();
@@ -99635,6 +99734,7 @@ init_dist6();
 init_logger2();
 init_estimation_distribution();
 init_platform_factory();
+init_schema2();
 init_template_library();
 init_errors();
 
@@ -100187,7 +100287,7 @@ function printReport(report, options, dryRun, storyIds) {
           continue;
         }
         output2.print(source_default.green(`✓ ${sanitizeTty(result.story.id)}: ${sanitizeTty(result.story.title)}`));
-        const withUnit = (value) => result.estimateUnit ? `${value} ${result.estimateUnit}` : String(value);
+        const withUnit = (value) => result.estimateUnit ? `${formatEstimateValue(value)} ${result.estimateUnit}` : formatEstimateValue(value);
         const rawEstimate = result.storyEstimate;
         const converted = result.estimationSummary?.storyEstimation;
         const conversionNote = converted !== undefined && converted !== rawEstimate ? ` (converted to ${withUnit(converted)})` : "";
@@ -103502,6 +103602,7 @@ tasks:                  # required, minimum 1 item
     tags: string[]      # optional
     id: string          # optional, required if this task is referenced in dependsOn
     dependsOn: string[] # optional, references other task ids
+    repeat: number      # optional, default 1 — create this many identical Tasks from this one definition (see rule 9)
     condition:          # optional — skip this task entirely when condition is false
       # Standard fields (case-sensitive, always lowercase camelCase — NOT the ADO REST field
       # names like "System.State" or "Microsoft.VSTS.Common.Priority"):
@@ -103535,8 +103636,9 @@ estimation:             # optional
   defaultParentEstimation: number | string   # optional — Story Estimate to assume with use-default, e.g. 5 or "M"
 
 validation:             # optional
-  minTasks: number
+  minTasks: number                # each copy of a repeated task counts
   maxTasks: number
+  maxRepeat: number               # optional, default 20 — the highest repeat any task may use
   totalEstimationMustBe: number   # usually 100
   totalEstimationRange:
     min: number
@@ -103551,7 +103653,7 @@ metadata:               # optional
 
 CONSTRAINTS (you must follow these):
 1. Estimation sums:
-   - Simple templates (no task-level conditions): estimationPercent values MUST sum to exactly 100.
+   - Simple templates (no task-level conditions): estimationPercent values MUST sum to exactly 100. A repeated task contributes its estimationPercent once per copy.
    - Multi-archetype templates (tasks use conditions to target different story types): each archetype's active task set should sum to ~100% independently. The total across all declared tasks will naturally exceed 100 — this is expected and valid.
 2. If a task uses dependsOn, all referenced IDs must exist on other tasks in the same template.
 3. workItemTypes values are case-sensitive strings matching ADO work item types.
@@ -103582,6 +103684,12 @@ CONSTRAINTS (you must follow these):
    - With a conversion table on a picklist source, use the picklist's allowed values exactly as keys and cover every one.
    - For a numeric scale where hours grow faster than points, use a table with numeric keys instead of a factor.
    - Conditions on estimation compare the raw Story Estimate: with size categories use equals/not-equals (e.g. value: "L"), never gt/lt/gte/lte.
+9. REPEATED TASKS — when the user wants several identical Tasks from the same definition (e.g. "one review task per developer, 4 developers"), write ONE task with repeat: N instead of copying the task block N times.
+   - Atomize titles the copies "<title> (1)", "<title> (2)", ... so do not number the title yourself.
+   - Each copy gets the task's full estimationPercent, so every copy counts toward the total: repeat: 4 at 10% contributes 40%.
+   - NEVER combine repeat with dependsOn, and never list a repeated task's id in another task's dependsOn.
+   - repeat must be a whole number, at most 20 unless you also set validation.maxRepeat to at least that number. Only raise maxRepeat when the user explicitly asks for more than 20 copies.
+   - Every copy is identical; when copies need different assignees, estimates or fields, write separate tasks instead.
 
 EXAMPLES:
 
@@ -103785,7 +103893,32 @@ filter:
 tasks:
   - id: "implement"
     title: "Implement (Mobile): \${story.title}"
-    estimationPercent: 60`;
+    estimationPercent: 60
+
+Example 7 — Repeated identical tasks (one review per developer):
+version: "1.0"
+name: "Team Review"
+description: "Implementation plus one review conclusions task for each of the four developers."
+filter:
+  workItemTypes: ["User Story"]
+  states: ["Active"]
+  excludeIfHasTasks: true
+tasks:
+  - title: "Implementation"
+    estimationPercent: 60
+    activity: "Development"
+    assignTo: "@ParentAssignee"
+  - title: "Add review conclusions"
+    estimationPercent: 10
+    repeat: 4
+    activity: "Development"
+    assignTo: "@Unassigned"
+estimation:
+  strategy: "percentage"
+metadata:
+  category: "Agile"
+  difficulty: "beginner"
+  estimationGuidelines: "60% + 4 copies × 10% = 100%."`;
 function buildSystemPrompt() {
   return SYSTEM_PROMPT;
 }
@@ -103854,6 +103987,7 @@ init_prompt_utilities();
 
 // src/cli/commands/template/template-wizard.ts
 init_dist6();
+init_schema2();
 init_errors();
 init_estimation_normalizer();
 init_source();
@@ -104348,12 +104482,22 @@ async function configureTaskTags(defaults) {
   return feature.data.length > 0 ? feature.data : undefined;
 }
 async function configureAdvancedTaskOptions(storyFieldSchemas, defaults) {
-  const dependsOnRaw = assertNotCancelled(await text({
-    message: "Depends on task IDs (comma-separated, optional):",
-    placeholder: "e.g. task-setup, task-db, task-build, task-test",
-    initialValue: defaults?.dependsOn?.join(", ") ?? ""
+  const repeatRaw = assertNotCancelled(await text({
+    message: "How many identical Tasks should this create?",
+    placeholder: "1",
+    initialValue: String(defaults?.repeat ?? 1),
+    validate: Validators.positiveInteger("Number of Tasks")
   }));
-  const dependsOn = Filters.commaSeparated(dependsOnRaw);
+  const repeat = Number(repeatRaw);
+  let dependsOn = [];
+  if (repeat === 1) {
+    const dependsOnRaw = assertNotCancelled(await text({
+      message: "Depends on task IDs (comma-separated, optional):",
+      placeholder: "e.g. task-setup, task-db, task-build, task-test",
+      initialValue: defaults?.dependsOn?.join(", ") ?? ""
+    }));
+    dependsOn = Filters.commaSeparated(dependsOnRaw);
+  }
   const addCondition = assertNotCancelled(await confirm({ message: "Add a task condition?", initialValue: false }));
   let condition;
   if (addCondition) {
@@ -104366,6 +104510,8 @@ async function configureAdvancedTaskOptions(storyFieldSchemas, defaults) {
     validate: Validators.priorityRange
   }));
   const result = {};
+  if (repeat > 1)
+    result.repeat = repeat;
   if (dependsOn.length > 0)
     result.dependsOn = dependsOn;
   if (condition)
@@ -104409,6 +104555,8 @@ async function buildTaskDefinition(isFirstTask, includeAdvanced, fieldSchemas, s
     }
     const advanced = await configureAdvancedTaskOptions(storyFieldSchemas, defaults);
     Object.assign(taskDef, advanced);
+  } else if (defaults?.repeat !== undefined) {
+    taskDef.repeat = defaults.repeat;
   }
   const customFields = await configureCustomFields(fieldSchemas, storyFieldSchemas);
   if (Object.keys(customFields).length > 0) {
@@ -104437,6 +104585,7 @@ function normalizeEstimations(tasks) {
   }
 }
 async function previewTemplate(template, ctx) {
+  await offerRepeatLimit(template);
   displayTemplatePreview(template);
   const action = assertNotCancelled(await select({
     message: "What would you like to do?",
@@ -104449,6 +104598,21 @@ async function previewTemplate(template, ctx) {
   }));
   return await handlePreviewAction(action, template, ctx);
 }
+async function offerRepeatLimit(template) {
+  const highest = Math.max(...template.tasks.map(copyCount));
+  const limit = template.validation?.maxRepeat ?? DEFAULT_MAX_REPEAT;
+  if (highest <= limit)
+    return;
+  const raise = assertNotCancelled(await confirm({
+    message: `A task creates ${highest} copies, above the limit of ${limit}. Raise the limit (validation.maxRepeat) to ${highest}?`,
+    initialValue: true
+  }));
+  if (raise)
+    template.validation = { ...template.validation, maxRepeat: highest };
+}
+function totalTaskPercent(tasks) {
+  return tasks.reduce((sum2, task) => sum2 + (task.estimationPercent || 0) * copyCount(task), 0);
+}
 function displayTemplatePreview(template) {
   output4.print(source_default.cyan(`
 Template Preview
@@ -104489,13 +104653,16 @@ Filter Configuration:`));
   }
 }
 function displayTasksSummary(template) {
+  const generated = template.tasks.reduce((sum2, task) => sum2 + copyCount(task), 0);
+  const counted = generated === template.tasks.length ? "" : `, ${generated} generated`;
   output4.print(source_default.bold(`
-Tasks (${template.tasks.length}):`));
-  const totalEstimation = template.tasks.reduce((sum2, task) => sum2 + (task.estimationPercent || 0), 0);
+Tasks (${template.tasks.length}${counted}):`));
+  const totalEstimation = totalTaskPercent(template.tasks);
   template.tasks.forEach((task, index) => {
     const percent = task.estimationPercent || 0;
     const bar = "■".repeat(Math.round(percent / 5));
-    output4.print(`  ${index + 1}. ${task.title} ${source_default.gray(`[${percent}%]`)} ${source_default.green(bar)}`);
+    const copies = copyCount(task) > 1 ? source_default.cyan(` ×${copyCount(task)}`) : "";
+    output4.print(`  ${index + 1}. ${task.title}${copies} ${source_default.gray(`[${percent}%]`)} ${source_default.green(bar)}`);
     if (task.description) {
       output4.print(source_default.gray(`     ${task.description}`));
     }
@@ -104525,6 +104692,9 @@ Validation Rules:`));
   if (template.validation.minTasks || template.validation.maxTasks) {
     output4.print(`  Task count: ${template.validation.minTasks || "no min"} - ${template.validation.maxTasks || "no max"}`);
   }
+  if (template.validation.maxRepeat !== undefined) {
+    output4.print(`  Copies per task: up to ${template.validation.maxRepeat}`);
+  }
 }
 function displayMetadata(template) {
   if (!template.metadata)
@@ -104726,13 +104896,17 @@ async function shouldAddMoreTasks(taskCounter) {
   }));
 }
 async function handleEstimationNormalization(tasks) {
-  const totalEstimation = tasks.reduce((sum2, task) => sum2 + (task.estimationPercent || 0), 0);
+  const totalEstimation = totalTaskPercent(tasks);
   if (totalEstimation === 100) {
     output4.print(source_default.green("✓ Total estimation is 100%"));
     return;
   }
   output4.print(source_default.yellow(`
   Warning: Total estimation is ${totalEstimation}% (should be 100%)`));
+  if (tasks.some((task) => copyCount(task) > 1)) {
+    output4.print(source_default.yellow("  Each copy of a repeated task counts toward the total; adjust the percentages to reach 100%."));
+    return;
+  }
   const shouldNormalize = await promptForNormalization();
   if (shouldNormalize) {
     normalizeEstimations(tasks);
@@ -104770,7 +104944,7 @@ async function editTasksInteractively(tasks, fieldSchemas, storyFieldSchemas) {
 Tasks (${currentTasks.length}) — total: ${totalLabel}
 `));
     currentTasks.forEach((t3, i3) => {
-      output4.print(source_default.gray(`  ${i3 + 1}. ${t3.title} [${t3.estimationPercent ?? 0}%]`));
+      output4.print(source_default.gray(`  ${i3 + 1}. ${t3.title}${copyCount(t3) > 1 ? ` ×${copyCount(t3)}` : ""} [${t3.estimationPercent ?? 0}%]`));
     });
     output4.blankLine();
   };
@@ -104792,7 +104966,7 @@ Tasks (${currentTasks.length}) — total: ${totalLabel}
         const idx = assertNotCancelled(await select({
           message: "Select task to edit:",
           options: currentTasks.map((t3, i3) => ({
-            label: `${i3 + 1}. ${t3.title} [${t3.estimationPercent ?? 0}%]`,
+            label: `${i3 + 1}. ${t3.title}${copyCount(t3) > 1 ? ` ×${copyCount(t3)}` : ""} [${t3.estimationPercent ?? 0}%]`,
             value: i3
           }))
         }));
@@ -104809,7 +104983,7 @@ Tasks (${currentTasks.length}) — total: ${totalLabel}
         const idx = assertNotCancelled(await select({
           message: "Select task to remove:",
           options: currentTasks.map((t3, i3) => ({
-            label: `${i3 + 1}. ${t3.title} [${t3.estimationPercent ?? 0}%]`,
+            label: `${i3 + 1}. ${t3.title}${copyCount(t3) > 1 ? ` ×${copyCount(t3)}` : ""} [${t3.estimationPercent ?? 0}%]`,
             value: i3
           }))
         }));
@@ -106509,6 +106683,7 @@ init_dist6();
 init_logger2();
 init_estimation_distribution();
 init_custom_field_verifier();
+init_schema2();
 init_template_library();
 init_errors();
 init_source();
@@ -106743,7 +106918,7 @@ function getTemplateSummary(template) {
   const totalPercent = totalUnconditionalEstimationPercent(template.tasks);
   return {
     name: template.name,
-    tasks: template.tasks.length,
+    tasks: generatedTaskCount(template.tasks),
     totalEstimation: `${totalPercent}%`
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sppg2001/atomize",
-	"version": "4.1.0",
+	"version": "4.2.0",
 	"description": "Automatically generate tasks from user stories with smart templates",
 	"type": "module",
 	"main": "./dist/cli/index.js",