@sppg2001/atomize 4.0.1 → 4.2.0

package/dist/cli/index.js

@@ -178,6 +178,35 @@ 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);
+}
+function isPlatformExcluded(field, rules) {
+  return field.referenceName.startsWith("System.") || matchesFieldPattern(field.referenceName, rules?.nonEstimateFields);
+}
+function isEstimateSourceField(field, rules) {
+  if (field.isReadOnly)
+    return false;
+  if (rules?.storyEstimateFields?.includes(field.referenceName))
+    return true;
+  if (isPlatformExcluded(field, rules))
+    return false;
+  return field.type === "integer" || field.type === "decimal" || field.type === "string" && !field.isMultiline;
+}
+function isEstimateTargetField(field, rules) {
+  return !field.isReadOnly && !field.isPicklist && (field.type === "integer" || field.type === "decimal") && !isPlatformExcluded(field, rules);
+}
+function sortEstimateFields(fields) {
+  const custom = (field) => Number(field.isCustom ?? field.referenceName.startsWith("Custom."));
+  return [...fields].sort((a, b) => custom(b) - custom(a) || a.name.localeCompare(b.name));
+}
+
 // ../atomize-schema/src/estimation-normalizer.ts
 function normalizeEstimationPercentages(items, options = {}) {
   const { skipIfAlreadyNormalized = true, tolerance = 0.01, targetTotal = 100 } = options;
@@ -20065,27 +20094,86 @@ var init_zod = __esm(() => {
 });
 
 // ../atomize-schema/src/schema.ts
+function lookupTableEstimate(value, table, multipliers = false) {
+  const text = String(value).trim();
+  if (Object.hasOwn(table, text))
+    return table[text];
+  if (!multipliers)
+    return;
+  const candidates = Object.keys(table).filter((key) => key !== "" && text.endsWith(key)).sort((a, b) => b.length - a.length);
+  for (const key of candidates) {
+    const prefix = text.slice(0, text.length - key.length).trim();
+    if (NUMBER_PATTERN.test(prefix))
+      return Number(prefix) * table[key];
+  }
+  return;
+}
+function isConvertibleStoryEstimate(value, conversion) {
+  if (conversion?.table)
+    return lookupTableEstimate(value, conversion.table, conversion.multipliers) !== undefined;
+  return typeof value === "number" || value.trim() !== "" && Number.isFinite(Number(value));
+}
 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 }
     });
   }
 }
@@ -20107,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) {
@@ -20124,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 }
       });
     }
   }
@@ -20162,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, 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;
@@ -20219,7 +20307,7 @@ var init_schema = __esm(() => {
   });
   FilterCriteriaSchema = exports_external.object({
     team: exports_external.string().describe("Azure DevOps team name. Limits story selection to stories owned by this team.").optional(),
-    workItemTypes: exports_external.array(exports_external.string()).describe("Work item types to include (e.g. ['User Story', 'Bug']).").optional(),
+    workItemTypes: exports_external.array(exports_external.string()).describe("Work item types to include (e.g. ['User Story', 'Bug']). With savedQuery, declares which types the query returns: it doesn't filter, but tells Atomize which fields to look up and validate.").optional(),
     states: exports_external.array(exports_external.string()).describe("Story states to target (e.g. ['Active', 'New']).").optional(),
     statesExclude: exports_external.array(exports_external.string()).describe("Story states to exclude from selection.").optional(),
     statesWereEver: exports_external.array(exports_external.string()).describe("Include stories that were ever in any of these states.").optional(),
@@ -20256,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(),
@@ -20276,14 +20365,42 @@ var init_schema = __esm(() => {
       return;
     })
   }).strict();
+  NUMBER_PATTERN = /^(?:\d+(?:\.\d+)?|\.\d+)$/;
+  EstimationConversionSchema = exports_external.object({
+    factor: exports_external.number().positive().describe("Multiplier from the Story's unit to the Task's unit, e.g. 4 when 1 point = 4 hours.").optional(),
+    table: exports_external.record(exports_external.string(), exports_external.number().nonnegative()).refine((table) => Object.keys(table).length > 0, "conversion.table must have at least one entry").describe("Story Estimate value to Task-unit amount, matched exactly, e.g. { XS: 1, S: 2, M: 4, L: 5 } or { 1: 2, 2: 4, 3: 8 } for scales that aren't linear.").optional(),
+    multipliers: exports_external.boolean().describe("Also accept a number followed by a table key, e.g. '0.3XL' = 0.3 × XL. Exact keys still win. Requires a table with non-numeric keys.").optional()
+  }).strict().refine((conversion) => conversion.factor === undefined !== (conversion.table === undefined), {
+    message: "conversion must set exactly one of factor or table"
+  }).refine((conversion) => !conversion.multipliers || conversion.table !== undefined, {
+    message: "conversion.multipliers requires conversion.table",
+    path: ["multipliers"]
+  }).refine((conversion) => !conversion.multipliers || !conversion.table || !Object.keys(conversion.table).every((key) => NUMBER_PATTERN.test(key)), {
+    message: "conversion.multipliers cannot be used when every table key is numeric: '25' would be ambiguous between the key 25 and 2 × 5",
+    path: ["multipliers"]
+  }).describe("Translates the Story Estimate into the Task's unit before it is split across tasks. Set exactly one of factor or table; omit for one-to-one.");
   EstimationConfigSchema = exports_external.object({
     strategy: exports_external.enum(["percentage"]).optional().default("percentage").describe("Estimation strategy. 'percentage' distributes the parent story's estimate across tasks proportionally."),
-    source: exports_external.string().describe("Field on the parent story to read the estimation value from (e.g. 'story-points').").optional(),
+    source: exports_external.string().min(1).describe("Story field that supplies the Story Estimate, as a platform field reference name (e.g. 'Custom.TShirtSize'). Replaces the platform's default fields, with no fallback. Omit to use the platform default.").optional(),
+    conversion: EstimationConversionSchema.optional(),
+    targetFields: exports_external.array(exports_external.string().min(1)).min(1, "targetFields must name at least one field").describe("Task fields that receive the Task Estimate, as platform field reference names. Replaces the platform's default estimate fields entirely; values are written exactly as calculated.").optional(),
+    normalize: exports_external.enum(["auto", "always", "never"]).describe("What to do when the generated tasks' percentages don't add up to 100%. 'auto' (default) scales totals below 100% up and leaves totals above 100% as written unless you choose otherwise at generate time; 'always' scales to 100% in both directions; 'never' uses the percentages exactly as written, so a skipped task's share stays unallocated.").optional(),
     rounding: exports_external.enum(["nearest", "up", "down", "none"]).optional().default("none").describe("Rounding mode applied to calculated task estimates: 'nearest', 'up', 'down', or 'none'."),
-    minimumTaskPoints: exports_external.number().describe("Minimum point value any single task can receive after rounding.").optional(),
-    ifParentHasNoEstimation: exports_external.enum(["skip", "warn", "use-default"]).describe("Behaviour when the parent story has no estimate. 'skip' omits tasks, 'warn' logs a warning, 'use-default' falls back to defaultParentEstimation.").optional(),
-    defaultParentEstimation: exports_external.number().describe("Fallback estimation value used when the parent story has no estimate and ifParentHasNoEstimation is 'use-default'.").optional()
-  }).strict();
+    minimumTaskEstimate: exports_external.number().describe("Minimum Task Estimate any single task can receive after rounding, in the Task's unit.").optional(),
+    minimumTaskPoints: exports_external.number().describe("Deprecated: use minimumTaskEstimate. Still honoured when minimumTaskEstimate is absent.").meta({ deprecated: true }).optional(),
+    ifParentHasNoEstimation: exports_external.enum(["skip", "warn", "use-default"]).describe("Behaviour when the Story Estimate is missing or cannot be converted. 'warn' (default) creates the tasks with blank estimates and reports a warning, 'skip' creates no tasks for the Story, 'use-default' uses defaultParentEstimation instead.").optional(),
+    defaultParentEstimation: exports_external.union([exports_external.number(), exports_external.string().min(1)]).describe("Story Estimate used when the real one is missing or cannot be converted and ifParentHasNoEstimation is 'use-default', in the Story's unit (e.g. 'M' or 5). Goes through the same conversion as a real Story Estimate.").optional()
+  }).strict().superRefine((config2, ctx) => {
+    if (config2.ifParentHasNoEstimation !== "use-default" || config2.defaultParentEstimation === undefined)
+      return;
+    if (isConvertibleStoryEstimate(config2.defaultParentEstimation, config2.conversion))
+      return;
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultParentEstimation"],
+      message: config2.conversion?.table ? `defaultParentEstimation "${config2.defaultParentEstimation}" is not a key of conversion.table${config2.conversion.multipliers ? " or a multiple of one" : ""}` : `defaultParentEstimation "${config2.defaultParentEstimation}" is not numeric and no conversion.table is set`
+    });
+  });
   ValidationModeSchema = exports_external.enum(["strict", "lenient"]).describe("'strict' fails on any validation warning; 'lenient' allows warnings to pass.");
   ValidationConfigSchema = exports_external.object({
     mode: ValidationModeSchema.describe("'strict' fails on any validation warning; 'lenient' allows warnings to pass.").optional(),
@@ -20294,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.")
@@ -20326,6 +20444,7 @@ var init_schema = __esm(() => {
     lastModified: exports_external.string().describe("ISO 8601 date of the last modification.").optional(),
     filter: FilterCriteriaSchema.describe("Criteria used to select which stories this template applies to."),
     tasks: exports_external.array(TaskDefinitionSchema).min(1, "At least one task is required").describe("Task definitions that will be generated from this template."),
+    taskType: exports_external.string().min(1).describe("Work Item type generated Tasks are created as, in the platform's own vocabulary (e.g. 'Task', 'Sub-task'). Omit to use the platform default.").optional(),
     estimation: EstimationConfigSchema.describe("Global estimation configuration for all tasks in this template.").optional(),
     validation: ValidationConfigSchema.describe("Validation rules applied when this template is used.").optional(),
     metadata: MetadataSchema.describe("Additional metadata for template discovery and documentation.").optional(),
@@ -20347,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);
@@ -20361,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)) {
@@ -20383,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);
   });
 });
 
@@ -20933,6 +21055,34 @@ var init_story_batch_processor = __esm(() => {
   init_errors();
 });
 
+// ../atomize-core/src/core/estimation-field-mapping.ts
+function resolveEstimationFieldMapping(defaults, overrides = {}) {
+  const storySource = overrides.source ? { kind: "override", field: overrides.source } : { kind: "default", fields: defaults.storyEstimateFields };
+  const taskTarget = overrides.targetFields?.length ? { kind: "override", fields: [...overrides.targetFields] } : { kind: "default", fields: defaults.taskEstimateFields };
+  return {
+    storySource,
+    taskWorkItemType: overrides.taskType ?? defaults.taskWorkItemType,
+    taskTarget,
+    unitLabel: taskTarget.kind === "default" ? defaults.unitLabel : undefined
+  };
+}
+function readStoryEstimate(story, source) {
+  const value = source.kind === "default" ? story.estimation : story.customFields?.[source.field];
+  return isStoryEstimate(value) ? value : undefined;
+}
+function numericStoryEstimate(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return;
+}
+function isStoryEstimate(value) {
+  return typeof value === "number" && Number.isFinite(value) || typeof value === "string" && value.trim() !== "";
+}
+
 // ../atomize-core/src/core/condition-evaluator.ts
 function extractStandardFieldRefs(condition) {
   const refs = [];
@@ -20966,22 +21116,29 @@ function extractCustomFieldRefs(condition) {
 }
 
 class ConditionEvaluator {
-  evaluateCondition(condition, story) {
+  evaluateCondition(condition, story, storyEstimateSource) {
     if (!condition)
       return true;
-    return this.evaluate(condition, story);
+    return this.evaluate(condition, story, storyEstimateSource);
   }
-  evaluate(condition, story) {
+  evaluate(condition, story, source) {
     if ("all" in condition) {
-      return condition.all.every((c2) => this.evaluate(c2, story));
+      return condition.all.every((c2) => this.evaluate(c2, story, source));
     }
     if ("any" in condition) {
-      return condition.any.some((c2) => this.evaluate(c2, story));
+      return condition.any.some((c2) => this.evaluate(c2, story, source));
     }
     if ("customField" in condition) {
       const fieldValue2 = story.customFields?.[condition.customField];
       return this.applyOperator(fieldValue2, condition.operator, condition.value);
     }
+    if (condition.field === "estimation") {
+      const estimate = readStoryEstimate(story, source ?? { kind: "default", fields: [] });
+      if (estimate !== undefined && NUMERIC_OPERATORS.has(condition.operator) && numericStoryEstimate(estimate) === undefined) {
+        throw new Error(`cannot compare the Story Estimate "${estimate}" with "${condition.operator}" because it is not numeric; use equals or not-equals for categories`);
+      }
+      return this.applyOperator(estimate, condition.operator, condition.value);
+    }
     const fieldValue = this.resolveField(condition.field, story);
     return this.applyOperator(fieldValue, condition.operator, condition.value);
   }
@@ -21052,8 +21209,69 @@ class ConditionEvaluator {
     return compare(a2, b2);
   }
 }
+var NUMERIC_OPERATORS;
 var init_condition_evaluator = __esm(() => {
   init_logger();
+  NUMERIC_OPERATORS = new Set(["gt", "lt", "gte", "lte"]);
+});
+
+// ../atomize-core/src/templates/schema.ts
+var init_schema2 = __esm(() => {
+  init_src();
+});
+
+// ../atomize-core/src/core/estimation-conversion.ts
+function convertStoryEstimate(raw, conversion) {
+  if (raw === undefined) {
+    return { kind: "unresolvable", reason: "Story has no estimate" };
+  }
+  if (conversion?.table) {
+    const total = lookupTableEstimate(raw, conversion.table, conversion.multipliers);
+    if (total === undefined) {
+      const suffix = conversion.multipliers ? " and is not a multiple of a table key" : "";
+      return { kind: "unresolvable", reason: `Story Estimate "${String(raw).trim()}" is not in the conversion table${suffix}` };
+    }
+    return { kind: "resolved", total: roundAwayFloatNoise(total) };
+  }
+  const numeric = numericStoryEstimate(raw);
+  if (numeric === undefined) {
+    return {
+      kind: "unresolvable",
+      reason: `Story Estimate "${raw}" is not numeric and the Template declares no conversion for it`
+    };
+  }
+  const factor = conversion?.factor ?? 1;
+  return { kind: "resolved", total: roundAwayFloatNoise(numeric * factor) };
+}
+function roundAwayFloatNoise(value) {
+  return Math.round(value * 1e9) / 1e9;
+}
+function resolveStoryEstimate(raw, config2) {
+  const converted = convertStoryEstimate(raw, config2?.conversion);
+  if (converted.kind === "resolved")
+    return converted;
+  switch (config2?.ifParentHasNoEstimation ?? "warn") {
+    case "skip":
+      return { kind: "skip", reason: converted.reason };
+    case "use-default": {
+      if (config2?.defaultParentEstimation === undefined) {
+        return {
+          kind: "blank",
+          reason: `${converted.reason}, and no defaultParentEstimation is set`
+        };
+      }
+      const fallback = convertStoryEstimate(config2.defaultParentEstimation, config2.conversion);
+      if (fallback.kind === "resolved") {
+        return { kind: "resolved", total: fallback.total, fallbackReason: converted.reason };
+      }
+      return { kind: "blank", reason: `${converted.reason}, and the default Story Estimate is unusable: ${fallback.reason}` };
+    }
+    default:
+      return { kind: "blank", reason: converted.reason };
+  }
+}
+var init_estimation_conversion = __esm(() => {
+  init_schema2();
 });
 
 // ../atomize-core/src/utils/estimation-normalizer.ts
@@ -21075,7 +21293,9 @@ var init_estimation_normalizer = __esm(() => {
 // ../atomize-core/src/core/estimation-distribution.ts
 function distributeActiveTaskPercentages(tasks, options = {}) {
   const totalBefore = totalEstimationPercent(tasks);
-  const normalized = totalBefore < 100 || totalBefore > 100 && options.forceNormalize === true ? normalizeEstimationPercentages2(tasks, {
+  const mode = options.mode ?? "auto";
+  const shouldNormalize = mode === "always" ? totalBefore !== 100 : mode === "never" ? false : totalBefore < 100 || totalBefore > 100 && options.forceNormalize === true;
+  const normalized = shouldNormalize ? normalizeEstimationPercentages2(tasks, {
     skipIfAlreadyNormalized: false,
     enableLogging: options.enableLogging ?? true
   }) : false;
@@ -21100,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) => {
@@ -21130,20 +21366,29 @@ class EstimationCalculator {
   constructor(conditionEvaluator = new ConditionEvaluator) {
     this.conditionEvaluator = conditionEvaluator;
   }
-  calculateTasksWithSkipped(story, connectUserEmail, templateTasks, estimationConfig, forceNormalize = false) {
+  calculateTasksWithSkipped(story, connectUserEmail, templateTasks, estimationConfig, forceNormalize = false, fieldMapping) {
     logger.debug(`EstimationCalculator: Calculating tasks for story ${story.id}`);
-    const parentEstimation = story.estimation || 0;
-    if (parentEstimation === 0) {
-      logger.warn(`Story ${story.id} has no estimation. Tasks will have 0 estimation.`);
+    const resolution = this.resolveParentEstimate(story, estimationConfig, fieldMapping);
+    if (resolution.kind === "skip") {
+      logger.warn(`Story ${story.id}: ${resolution.reason}. Skipping the Story.`);
+      return {
+        calculatedTasks: [],
+        skippedTasks: [],
+        unresolvedEstimate: { action: "skip", reason: resolution.reason }
+      };
+    }
+    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) {
         let conditionMet;
         try {
-          conditionMet = this.conditionEvaluator.evaluateCondition(templateTask.condition, story);
+          conditionMet = this.conditionEvaluator.evaluateCondition(templateTask.condition, story, fieldMapping?.storySource);
         } catch (error62) {
           const reason = `Condition evaluation error: ${getErrorMessage(error62)}`;
           logger.error(`Skipping task "${templateTask.title}" - ${reason}`);
@@ -21158,25 +21403,52 @@ class EstimationCalculator {
         }
         logger.debug(`Task "${templateTask.title}" - condition met: ${JSON.stringify(templateTask.condition)}`);
       }
-      const resolvedPercent = this.resolveEffectivePercent(templateTask, story);
-      const calculatedTask = this.buildCalculatedTask(templateTask, story, connectUserEmail, 0, resolvedPercent);
-      calculatedTasks.push(calculatedTask);
+      let resolvedPercent;
+      try {
+        resolvedPercent = this.resolveEffectivePercent(templateTask, story, fieldMapping);
+      } catch (error62) {
+        const reason = `Condition evaluation error: ${getErrorMessage(error62)}`;
+        logger.error(`Skipping task "${templateTask.title}" - ${reason}`);
+        skippedTasks.push({ templateTask, reason });
+        continue;
+      }
+      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;
+        if (fieldMapping.taskTarget.kind === "override") {
+          task.estimateFields = [...fieldMapping.taskTarget.fields];
+        }
+      }
     }
     distributeActiveTaskPercentages(calculatedTasks, {
       forceNormalize,
-      enableLogging: true
+      enableLogging: true,
+      mode: estimationConfig?.normalize
     });
     for (const calculatedTask of calculatedTasks) {
-      calculatedTask.estimation = this.calculateEstimation(parentEstimation, calculatedTask, estimationConfig);
-      logger.debug(`Calculated task: ${calculatedTask.title} = ${calculatedTask.estimation} points (${calculatedTask.estimationPercent}%)`);
+      calculatedTask.estimation = resolution.kind === "resolved" ? this.calculateEstimation(resolution.total, calculatedTask, estimationConfig) : calculatedTask.estimationFixed;
+      logger.debug(`Calculated task: ${calculatedTask.title} = ${calculatedTask.estimation ?? "unestimated"} (${calculatedTask.estimationPercent}%)`);
     }
     logger.info(`EstimationCalculator: Calculated ${calculatedTasks.length} tasks, skipped ${skippedTasks.length} tasks for story ${story.id}`);
-    return { calculatedTasks, skippedTasks };
+    return {
+      calculatedTasks,
+      skippedTasks,
+      ...resolution.kind === "blank" ? { unresolvedEstimate: { action: "blank", reason: resolution.reason } } : {},
+      ...resolution.kind === "resolved" && resolution.fallbackReason ? { defaultEstimateReason: resolution.fallbackReason } : {}
+    };
   }
-  resolveEffectivePercent(task, story) {
+  resolveEffectivePercent(task, story, fieldMapping) {
     if (task.estimationPercentCondition?.length) {
       for (const rule of task.estimationPercentCondition) {
-        if (this.conditionEvaluator.evaluateCondition(rule.condition, story)) {
+        if (this.conditionEvaluator.evaluateCondition(rule.condition, story, fieldMapping?.storySource)) {
           logger.debug(`Task "${task.title}": conditional percent → ${rule.percent}%`);
           return rule.percent;
         }
@@ -21193,7 +21465,6 @@ class EstimationCalculator {
       assignTo: this.resolveAssignment(templateTask.assignTo, story, connectUserEmail),
       priority: templateTask.priority,
       activity: templateTask.activity,
-      completedWork: 0,
       iteration: story.iteration,
       areaPath: story.areaPath,
       customFields: this.interpolateCustomFields(templateTask.customFields, story),
@@ -21202,6 +21473,10 @@ class EstimationCalculator {
       estimationFixed: templateTask.estimationFixed
     };
   }
+  resolveParentEstimate(story, config2, fieldMapping) {
+    const raw = readStoryEstimate(story, fieldMapping?.storySource ?? { kind: "default", fields: [] });
+    return resolveStoryEstimate(raw, config2);
+  }
   calculateEstimation(parentEstimation, task, config2) {
     if (task.estimationFixed !== undefined) {
       return task.estimationFixed;
@@ -21209,7 +21484,7 @@ class EstimationCalculator {
     if (task.estimationPercent !== undefined) {
       const rawEstimation = parentEstimation * task.estimationPercent / 100;
       const rounded = this.roundEstimation(rawEstimation, config2?.rounding || "none");
-      const minimum = config2?.minimumTaskPoints || 0;
+      const minimum = config2?.minimumTaskEstimate ?? config2?.minimumTaskPoints ?? 0;
       return Math.max(rounded, minimum);
     }
     if (task.estimationFormula) {
@@ -21252,8 +21527,9 @@ class EstimationCalculator {
   calculateTotalEstimation(tasks) {
     return tasks.reduce((sum, task) => sum + (task.estimation || 0), 0);
   }
-  getEstimationSummary(story, tasks) {
-    const storyEstimation = story.estimation || 0;
+  getEstimationSummary(story, tasks, config2, fieldMapping) {
+    const resolution = this.resolveParentEstimate(story, config2, fieldMapping);
+    const storyEstimation = resolution.kind === "resolved" ? resolution.total : 0;
     const totalTaskEstimation = this.calculateTotalEstimation(tasks);
     const difference = storyEstimation - totalTaskEstimation;
     const percentageUsed = storyEstimation > 0 ? totalTaskEstimation / storyEstimation * 100 : 0;
@@ -21264,13 +21540,16 @@ class EstimationCalculator {
       percentageUsed
     };
   }
-  validateEstimation(story, tasks) {
+  validateEstimation(story, tasks, config2, fieldMapping) {
     const warnings = [];
-    const summary = this.getEstimationSummary(story, tasks);
+    if (this.resolveParentEstimate(story, config2, fieldMapping).kind !== "resolved") {
+      return { valid: true, warnings };
+    }
+    const summary = this.getEstimationSummary(story, tasks, config2, fieldMapping);
     if (Math.abs(summary.difference) > 0.5) {
       warnings.push(`Total task estimation (${summary.totalTaskEstimation}) differs from story estimation (${summary.storyEstimation}) by ${summary.difference}`);
     }
-    const zeroEstimations = tasks.filter((t2) => (t2.estimation || 0) === 0);
+    const zeroEstimations = tasks.filter((t2) => t2.estimation === 0);
     if (zeroEstimations.length > 0) {
       warnings.push(`${zeroEstimations.length} task(s) have zero estimation: ${zeroEstimations.map((t2) => t2.title).join(", ")}`);
     }
@@ -21285,6 +21564,7 @@ var init_estimation_calculator = __esm(() => {
   init_logger();
   init_errors();
   init_condition_evaluator();
+  init_estimation_conversion();
   init_estimation_distribution();
 });
 
@@ -21361,27 +21641,54 @@ var init_task_materializer = __esm(() => {
 class StoryProcessor {
   estimationCalculator;
   taskMaterializer;
+  estimationDefaults;
   constructor(platform, estimationCalculator = new EstimationCalculator, taskMaterializer = new TaskMaterializer(platform)) {
     this.estimationCalculator = estimationCalculator;
     this.taskMaterializer = taskMaterializer;
+    this.estimationDefaults = platform.getEstimationDefaults?.();
   }
   async process(story, orderedTasks, template, connectUserEmail, options, warnings) {
     logger.info(`Processing: ${story.id} - ${story.title}`);
-    const { calculatedTasks, skippedTasks } = this.estimationCalculator.calculateTasksWithSkipped(story, connectUserEmail, orderedTasks, template.estimation, options.forceNormalize);
+    const fieldMapping = this.estimationDefaults ? resolveEstimationFieldMapping(this.estimationDefaults, {
+      source: template.estimation?.source,
+      taskType: template.taskType,
+      targetFields: template.estimation?.targetFields
+    }) : undefined;
+    const { calculatedTasks, skippedTasks, unresolvedEstimate, defaultEstimateReason } = this.estimationCalculator.calculateTasksWithSkipped(story, connectUserEmail, orderedTasks, template.estimation, options.forceNormalize, fieldMapping);
     logger.info(`Generated ${calculatedTasks.length} tasks, skipped ${skippedTasks.length} conditional tasks`);
+    if (unresolvedEstimate?.action === "skip") {
+      const skipReason = `${unresolvedEstimate.reason}; Story skipped (ifParentHasNoEstimation: skip)`;
+      warnings.push(`${story.id}: ${skipReason}`);
+      return {
+        story,
+        tasksCalculated: [],
+        tasksCreated: [],
+        tasksSkipped: [],
+        success: true,
+        ...fieldMapping?.unitLabel ? { estimateUnit: fieldMapping.unitLabel } : {},
+        ...withStoryEstimate(readStoryEstimate(story, fieldMapping?.storySource ?? { kind: "default", fields: [] })),
+        skipReason
+      };
+    }
+    if (unresolvedEstimate?.action === "blank") {
+      warnings.push(`${story.id}: ${unresolvedEstimate.reason}; Task Estimates left blank`);
+    }
+    if (defaultEstimateReason) {
+      warnings.push(`${story.id}: ${defaultEstimateReason}; used defaultParentEstimation`);
+    }
     if (skippedTasks.length > 0) {
       skippedTasks.forEach((skipped) => {
         logger.debug(`  Skipped: "${skipped.templateTask.title}" - ${skipped.reason}`);
       });
     }
-    const validation = this.estimationCalculator.validateEstimation(story, calculatedTasks);
+    const validation = this.estimationCalculator.validateEstimation(story, calculatedTasks, template.estimation, fieldMapping);
     if (!validation.valid) {
       validation.warnings.forEach((warning) => {
         logger.warn(`${warning}`);
         warnings.push(`${story.id}: ${warning}`);
       });
     }
-    const estimationSummary = this.estimationCalculator.getEstimationSummary(story, calculatedTasks);
+    const estimationSummary = this.estimationCalculator.getEstimationSummary(story, calculatedTasks, template.estimation, fieldMapping);
     logger.debug("Estimation summary:", estimationSummary);
     let tasksCreated = [];
     if (options.dryRun) {
@@ -21397,10 +21704,15 @@ class StoryProcessor {
       tasksCreated,
       tasksSkipped: skippedTasks,
       success: true,
+      ...fieldMapping?.unitLabel ? { estimateUnit: fieldMapping.unitLabel } : {},
+      ...withStoryEstimate(readStoryEstimate(story, fieldMapping?.storySource ?? { kind: "default", fields: [] })),
       estimationSummary
     };
   }
 }
+function withStoryEstimate(estimate) {
+  return estimate === undefined ? {} : { storyEstimate: estimate };
+}
 var init_story_processor = __esm(() => {
   init_logger();
   init_estimation_calculator();
@@ -79871,29 +80183,33 @@ class FieldSchemaService {
     const allowedValues = witField.allowedValues && witField.allowedValues.length > 0 ? witField.allowedValues : undefined;
     const isPicklist = !!(allowedValues ?? meta3?.isPicklist);
     const isIdentity = meta3?.isIdentity === true || fieldType === import_WorkItemTrackingInterfaces.FieldType.Identity;
+    const type = isIdentity ? "identity" : this.mapFieldType(fieldType);
     return {
       referenceName,
       name: witField.name ?? meta3?.name ?? referenceName,
-      type: isIdentity ? "identity" : this.mapFieldType(fieldType),
+      type,
       isCustom: referenceName.startsWith("Custom."),
       isReadOnly: meta3?.readOnly ?? false,
       isMultiline: !isPicklist && (fieldType === import_WorkItemTrackingInterfaces.FieldType.Html || fieldType === import_WorkItemTrackingInterfaces.FieldType.PlainText),
       isPicklist,
-      allowedValues
+      allowedValues,
+      allowsCustomValues: isPicklist ? meta3?.isPicklistSuggested === true : type === "string"
     };
   }
   mapWorkItemField(f) {
     const referenceName = f.referenceName ?? "";
     const isIdentity = f.isIdentity === true || f.type === import_WorkItemTrackingInterfaces.FieldType.Identity;
+    const type = isIdentity ? "identity" : this.mapFieldType(f.type);
     return {
       referenceName,
       name: f.name ?? referenceName,
-      type: isIdentity ? "identity" : this.mapFieldType(f.type),
+      type,
       isCustom: referenceName.startsWith("Custom."),
       isReadOnly: f.readOnly ?? false,
       isMultiline: !f.isPicklist && (f.type === import_WorkItemTrackingInterfaces.FieldType.Html || f.type === import_WorkItemTrackingInterfaces.FieldType.PlainText),
       isPicklist: f.isPicklist ?? false,
-      allowedValues: undefined
+      allowedValues: undefined,
+      allowsCustomValues: f.isPicklist ? f.isPicklistSuggested === true : type === "string"
     };
   }
   mapFieldType(fieldType) {
@@ -79920,6 +80236,33 @@ var init_azure_devops_field_schema_service = __esm(() => {
   import_WorkItemTrackingInterfaces = __toESM(require_WorkItemTrackingInterfaces(), 1);
 });
 
+// ../atomize-core/src/platforms/adapters/azure-devops/estimation-defaults.ts
+var AZURE_DEVOPS_ESTIMATION_DEFAULTS;
+var init_estimation_defaults = __esm(() => {
+  AZURE_DEVOPS_ESTIMATION_DEFAULTS = {
+    storyEstimateFields: [
+      "Microsoft.VSTS.Scheduling.StoryPoints",
+      "Microsoft.VSTS.Scheduling.Effort",
+      "Microsoft.VSTS.Scheduling.Size",
+      "Microsoft.VSTS.Scheduling.OriginalEstimate"
+    ],
+    taskWorkItemType: "Task",
+    taskEstimateFields: [
+      "Microsoft.VSTS.Scheduling.RemainingWork",
+      "Microsoft.VSTS.Scheduling.OriginalEstimate"
+    ],
+    unitLabel: "hours",
+    nonEstimateFields: [
+      "Microsoft.VSTS.Common.*",
+      "Microsoft.VSTS.Build.*",
+      "Microsoft.VSTS.CMMI.*",
+      "Microsoft.VSTS.CodeReview.*",
+      "Microsoft.VSTS.Feedback.*",
+      "Microsoft.VSTS.TCM.*"
+    ]
+  };
+});
+
 // ../atomize-core/src/platforms/adapters/azure-devops/task-patch-builder.ts
 function resolveDateMacro(value) {
   if (typeof value !== "string")
@@ -79951,7 +80294,7 @@ function resolveDateMacro(value) {
   base.setDate(base.getDate() + offsetDays);
   return base.toISOString().slice(0, 10);
 }
-function buildCreateTaskPatch(organizationUrl, parentId, task) {
+function buildCreateTaskPatch(organizationUrl, parentId, task, estimateWrite) {
   return [
     {
       op: "add",
@@ -79965,25 +80308,12 @@ function buildCreateTaskPatch(organizationUrl, parentId, task) {
         value: task.description
       }
     ] : [],
-    ...task.estimation !== undefined ? [
-      {
-        op: "add",
-        path: "/fields/Microsoft.VSTS.Scheduling.RemainingWork",
-        value: task.estimation
-      },
-      {
-        op: "add",
-        path: "/fields/Microsoft.VSTS.Scheduling.OriginalEstimate",
-        value: task.estimation
-      }
-    ] : [],
-    ...task.completedWork !== undefined ? [
-      {
-        op: "add",
-        path: "/fields/Microsoft.VSTS.Scheduling.CompletedWork",
-        value: task.completedWork
-      }
-    ] : [],
+    ...task.estimation !== undefined ? estimateWrite.fields.map((field) => ({
+      op: "add",
+      path: `/fields/${field}`,
+      value: task.estimation
+    })) : [],
+    ...estimateWrite.initializeCompletedWork ? [{ op: "add", path: "/fields/Microsoft.VSTS.Scheduling.CompletedWork", value: 0 }] : [],
     ...task.iteration ? [
       {
         op: "add",
@@ -80065,6 +80395,14 @@ var init_task_patch_builder = __esm(() => {
 });
 
 // ../atomize-core/src/platforms/adapters/azure-devops/work-item-mapper.ts
+function firstEstimate(fields) {
+  for (const field of AZURE_DEVOPS_ESTIMATION_DEFAULTS.storyEstimateFields) {
+    const value = fields[field];
+    if ((typeof value === "number" || typeof value === "string") && value)
+      return value;
+  }
+  return;
+}
 function convertWorkItem(azureItem) {
   const fields = azureItem.fields || {};
   const predecessorIds = [];
@@ -80091,7 +80429,7 @@ function convertWorkItem(azureItem) {
     type: fields["System.WorkItemType"],
     state: fields["System.State"] || "",
     assignedTo: fields["System.AssignedTo"]?.uniqueName || fields["System.AssignedTo"]?.displayName,
-    estimation: fields["Microsoft.VSTS.Scheduling.StoryPoints"] || fields["Microsoft.VSTS.Scheduling.OriginalEstimate"],
+    estimation: firstEstimate(fields),
     tags: fields["System.Tags"] ? fields["System.Tags"].split("; ") : [],
     description: fields["System.Description"],
     areaPath: fields["System.AreaPath"],
@@ -80115,10 +80453,8 @@ function hasChildRelations(workItem) {
   }
   return workItem.relations.some((rel) => rel.rel === "System.LinkTypes.Hierarchy-Forward");
 }
-
-// ../atomize-core/src/templates/schema.ts
-var init_schema2 = __esm(() => {
-  init_src();
+var init_work_item_mapper = __esm(() => {
+  init_estimation_defaults();
 });
 
 // ../atomize-core/src/platforms/adapters/azure-devops/work-item-query.ts
@@ -80383,6 +80719,7 @@ var import_WorkItemTrackingInterfaces2;
 var init_work_item_retrieval = __esm(() => {
   init_logger();
   init_errors();
+  init_work_item_mapper();
   init_work_item_query();
   import_WorkItemTrackingInterfaces2 = __toESM(require_WorkItemTrackingInterfaces(), 1);
 });
@@ -80490,11 +80827,13 @@ class AzureDevOpsAdapter {
       if (Number.isNaN(numericParentId)) {
         throw new Error(`Invalid parent ID: ${parentId}`);
       }
-      const patchDocument = buildCreateTaskPatch(this.config.organizationUrl, numericParentId, task);
+      const defaults = this.getEstimationDefaults();
+      const estimateWrite = task.estimateFields?.length ? { fields: task.estimateFields } : { fields: defaults.taskEstimateFields, initializeCompletedWork: true };
+      const patchDocument = buildCreateTaskPatch(this.config.organizationUrl, numericParentId, task, estimateWrite);
       if (!this.witApi) {
         throw new UnknownError("Work Item Tracking API not initialized");
       }
-      const createdItem = await this.witApi.createWorkItem(undefined, patchDocument, this.config.project, "Task");
+      const createdItem = await this.witApi.createWorkItem(undefined, patchDocument, this.config.project, task.workItemType ?? defaults.taskWorkItemType);
       logger.info(`AzureDevOps: Created task ${createdItem.id}: ${task.title}`);
       return convertWorkItem(createdItem);
     } catch (error62) {
@@ -80531,6 +80870,9 @@ class AzureDevOpsAdapter {
     logger.info(`AzureDevOps: Created ${createdTasks.length} of ${tasks.length} tasks`);
     return createdTasks;
   }
+  getEstimationDefaults() {
+    return AZURE_DEVOPS_ESTIMATION_DEFAULTS;
+  }
   getPlatformMetadata() {
     return {
       name: "Azure DevOps",
@@ -80743,7 +81085,9 @@ var init_azure_devops_adapter = __esm(() => {
   init_logger();
   init_errors();
   init_azure_devops_field_schema_service();
+  init_estimation_defaults();
   init_task_patch_builder();
+  init_work_item_mapper();
   init_work_item_query();
   init_work_item_retrieval();
   azdev = __toESM(require_WebApi(), 1);
@@ -80995,7 +81339,7 @@ class MockPlatformAdapter {
     const createdTask = {
       id: `TASK-${this.taskIdCounter++}`,
       title: task.title,
-      type: "Task",
+      type: task.workItemType ?? MOCK_ESTIMATION_DEFAULTS.taskWorkItemType,
       state: "New",
       assignedTo: task.assignTo,
       estimation: task.estimation,
@@ -81063,6 +81407,9 @@ class MockPlatformAdapter {
     logger.info(`MockPlatform: Deleted work item ${id}`);
     return true;
   }
+  getEstimationDefaults() {
+    return MOCK_ESTIMATION_DEFAULTS;
+  }
   getPlatformMetadata() {
     return {
       name: "Mock Platform",
@@ -81109,9 +81456,16 @@ class MockPlatformAdapter {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 }
+var MOCK_ESTIMATION_DEFAULTS;
 var init_mock_adapter = __esm(() => {
   init_logger();
   init_mock_data();
+  MOCK_ESTIMATION_DEFAULTS = {
+    storyEstimateFields: ["estimation"],
+    taskWorkItemType: "Task",
+    taskEstimateFields: ["estimation"],
+    unitLabel: "hours"
+  };
 });
 
 // ../atomize-core/src/platforms/platform-factory.ts
@@ -88764,6 +89118,7 @@ function mergeTemplates(base, child) {
     lastModified: child.lastModified ?? base.lastModified,
     filter: child.filter ?? base.filter,
     tasks: mergeTasks(base.tasks, child.tasks ?? []),
+    taskType: child.taskType ?? base.taskType,
     estimation: child.estimation ?? base.estimation,
     validation: child.validation ?? base.validation,
     metadata: child.metadata ?? base.metadata
@@ -89195,12 +89550,13 @@ 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;
-    if (!hasStrictRule && total > 100) {
+    const normalize = template.estimation?.normalize ?? "auto";
+    if (!hasStrictRule && total > 100 && normalize !== "always") {
       warnings.push({
         path: "tasks",
-        message: `Total estimation is ${total}% (exceeds 100%). This is valid when tasks span multiple roles. You will be prompted to normalise at generate time.`,
+        message: normalize === "never" ? `Total estimation is ${total}% (exceeds 100%). With normalize: never, tasks are generated with these percentages as written.` : `Total estimation is ${total}% (exceeds 100%). This is valid when tasks span multiple roles. You will be prompted to normalise at generate time.`,
         nonBlocking: true
       });
     }
@@ -89215,8 +89571,31 @@ class TemplateValidator {
     this.validateTaskConditions(template, warnings);
     this.validateTaskDependencies(template, warnings);
     this.validateSavedQueryConflict(template, warnings);
+    this.validateDeprecatedMinimumTaskPoints(template, warnings);
     return warnings;
   }
+  validateDeprecatedMinimumTaskPoints(template, warnings) {
+    const estimation = template.estimation;
+    if (estimation?.minimumTaskPoints === undefined)
+      return;
+    if (estimation.minimumTaskEstimate === undefined) {
+      warnings.push({
+        path: "estimation.minimumTaskPoints",
+        message: "minimumTaskPoints is deprecated; the minimum applies in the Task's unit, which may not be points.",
+        suggestion: `Rename it to minimumTaskEstimate: ${estimation.minimumTaskPoints}.`,
+        code: FixableWarningCode.DEPRECATED_MINIMUM_TASK_POINTS,
+        nonBlocking: true
+      });
+      return;
+    }
+    warnings.push({
+      path: "estimation.minimumTaskPoints",
+      message: `Both minimumTaskEstimate and the deprecated minimumTaskPoints are set; minimumTaskEstimate (${estimation.minimumTaskEstimate}) is used and minimumTaskPoints (${estimation.minimumTaskPoints}) is ignored.`,
+      suggestion: "Remove minimumTaskPoints.",
+      code: FixableWarningCode.DUPLICATE_MINIMUM_TASK_ESTIMATE,
+      nonBlocking: true
+    });
+  }
   collectMixinWarnings(mixin) {
     const warnings = [];
     this.validateTaskDependencies(mixin, warnings);
@@ -89266,13 +89645,13 @@ class TemplateValidator {
     const f = template.filter;
     if (!f.savedQuery)
       return;
-    const hasStructuredFields = f.workItemTypes || f.states || f.statesExclude || f.statesWereEver || f.tags?.include || f.tags?.exclude || f.areaPaths || f.areaPathsUnder || f.iterations || f.iterationsUnder || f.assignedTo || f.changedAfter || f.createdAfter || f.priority;
+    const hasStructuredFields = f.states || f.statesExclude || f.statesWereEver || f.tags?.include || f.tags?.exclude || f.areaPaths || f.areaPathsUnder || f.iterations || f.iterationsUnder || f.assignedTo || f.changedAfter || f.createdAfter || f.priority;
     if (hasStructuredFields) {
       warnings.push({
         path: "filter.savedQuery",
         message: "savedQuery and structured filter fields are both set. Structured filter fields will be ignored — the saved query controls which items are returned.",
         code: FixableWarningCode.SAVED_QUERY_WITH_STRUCTURED_FILTER,
-        suggestion: "Remove workItemTypes, states, tags, etc. from the filter when using savedQuery."
+        suggestion: "Remove states, tags, area paths, etc. from the filter when using savedQuery. Keep workItemTypes: it declares which types the query returns."
       });
     }
   }
@@ -89297,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;
@@ -89325,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.";
@@ -89333,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)
@@ -89417,15 +89817,18 @@ var init_validator = __esm(() => {
   FixableWarningCode = {
     MISSING_TASK_ID: "MISSING_TASK_ID",
     SAVED_QUERY_WITH_STRUCTURED_FILTER: "SAVED_QUERY_WITH_STRUCTURED_FILTER",
-    SINGLE_LINE_FIELD_WITH_NEWLINES: "SINGLE_LINE_FIELD_WITH_NEWLINES"
+    SINGLE_LINE_FIELD_WITH_NEWLINES: "SINGLE_LINE_FIELD_WITH_NEWLINES",
+    DEPRECATED_MINIMUM_TASK_POINTS: "DEPRECATED_MINIMUM_TASK_POINTS",
+    DUPLICATE_MINIMUM_TASK_ESTIMATE: "DUPLICATE_MINIMUM_TASK_ESTIMATE"
   };
 });
 
 // ../atomize-core/src/templates/custom-field-verifier.ts
-async function verifyTemplateCustomFields(template, getSchemas) {
+async function verifyTemplateCustomFields(template, getSchemas, taskWorkItemType) {
   const errors4 = [];
   const warnings = [];
-  const taskSchemas = await getSchemas("Task");
+  const taskSchemas = await getSchemas(taskWorkItemType);
+  const scope = taskWorkItemType ? `work item type "${taskWorkItemType}"` : "this project";
   const schemaByRef = new Map(taskSchemas.map((field) => [field.referenceName, field]));
   for (let i2 = 0;i2 < template.tasks.length; i2++) {
     const task = template.tasks[i2];
@@ -89437,7 +89840,7 @@ async function verifyTemplateCustomFields(template, getSchemas) {
       if (!schema2) {
         errors4.push({
           path,
-          message: `Field "${refName}" not found for work item type "Task".`,
+          message: `Field "${refName}" not found for ${scope}.`,
           code: "CUSTOM_FIELD_NOT_FOUND"
         });
         continue;
@@ -89589,16 +89992,166 @@ var init_custom_field_verifier = __esm(() => {
   init_validator();
 });
 
+// ../atomize-core/src/templates/estimation-verifier.ts
+function hasEstimationMappingOverrides(template) {
+  return !!(template.taskType || template.estimation?.source || template.estimation?.targetFields?.length);
+}
+async function verifyEstimationMapping(template, platform) {
+  const errors4 = [];
+  const warnings = [];
+  if (!hasEstimationMappingOverrides(template))
+    return { errors: errors4, warnings };
+  const taskType = template.taskType ?? platform.getEstimationDefaults?.().taskWorkItemType;
+  const nonEstimateFields = platform.getEstimationDefaults?.().nonEstimateFields ?? [];
+  const taskTypeExists = await verifyTaskType(template, platform, errors4);
+  const targetFields = template.estimation?.targetFields ?? [];
+  if (targetFields.length > 0 && taskType && taskTypeExists) {
+    const taskFields = byReference(await platform.getFieldSchemas(taskType));
+    targetFields.forEach((ref, i2) => {
+      const path = `estimation.targetFields[${i2}]`;
+      const field = taskFields.get(ref);
+      if (!field) {
+        errors4.push({ path, message: `Field "${ref}" not found for work item type "${taskType}".`, code: "ESTIMATION_TARGET_FIELD_NOT_FOUND" });
+      } else if (!NUMERIC_TYPES.has(field.type)) {
+        errors4.push({
+          path,
+          message: `Field "${ref}" is a ${field.type} field; Task Estimates can only be written to numeric fields.`,
+          code: "ESTIMATION_TARGET_FIELD_NOT_NUMERIC"
+        });
+      } else if (field.isPicklist) {
+        errors4.push({
+          path,
+          message: `Field "${ref}" only accepts a fixed list of values, so calculated Task Estimates can't be written to it.`,
+          code: "ESTIMATION_TARGET_FIELD_PICKLIST"
+        });
+      } else if (matchesFieldPattern(ref, nonEstimateFields)) {
+        warnings.push({
+          path,
+          message: `Field "${ref}" holds a ranking or value, not effort; writing Task Estimates to it will overwrite that.`,
+          suggestion: "Choose an effort field such as the platform's default estimate fields or a custom effort field."
+        });
+      }
+    });
+  }
+  const source = template.estimation?.source;
+  if (source) {
+    const sourceField = await verifySourceField(template, source, platform, errors4);
+    if (sourceField)
+      checkSourceValues(template, sourceField, warnings);
+  }
+  return { errors: errors4, warnings };
+}
+async function verifyTaskType(template, platform, errors4) {
+  if (!template.taskType || !platform.getWorkItemTypes)
+    return true;
+  const types = await platform.getWorkItemTypes();
+  if (types.includes(template.taskType))
+    return true;
+  errors4.push({
+    path: "taskType",
+    message: `Work item type "${template.taskType}" does not exist in this project. Available types: ${types.join(", ")}.`,
+    code: "ESTIMATION_TASK_TYPE_NOT_FOUND"
+  });
+  return false;
+}
+async function verifySourceField(template, source, platform, errors4) {
+  const storyTypes = template.filter.workItemTypes?.length ? template.filter.workItemTypes : [undefined];
+  let found;
+  for (const storyType of storyTypes) {
+    const field = byReference(await platform.getFieldSchemas(storyType)).get(source);
+    if (field) {
+      found ??= field;
+      continue;
+    }
+    errors4.push({
+      path: "estimation.source",
+      message: storyType ? `Field "${source}" not found for work item type "${storyType}".` : `Field "${source}" not found in this project.`,
+      code: "ESTIMATION_SOURCE_NOT_FOUND"
+    });
+  }
+  return found;
+}
+function checkSourceValues(template, field, warnings) {
+  const table = template.estimation?.conversion?.table;
+  const multipliers = template.estimation?.conversion?.multipliers === true;
+  const allowed = field.isPicklist ? field.allowedValues ?? [] : [];
+  if (table && allowed.length > 0) {
+    const keys = Object.keys(table);
+    const uncovered = allowed.filter((value) => lookupTableEstimate(value, table, multipliers) === undefined);
+    if (uncovered.length > 0) {
+      warnings.push({
+        path: "estimation.conversion.table",
+        message: `${listValues(uncovered)} ${uncovered.length === 1 ? "is a valid value" : "are valid values"} of "${field.referenceName}" but ${uncovered.length === 1 ? "has" : "have"} no conversion; Stories with ${uncovered.length === 1 ? "it" : "them"} will get blank Task Estimates.`,
+        suggestion: "Add the missing values to conversion.table."
+      });
+    }
+    const usedThroughMultiplier = (key) => multipliers && allowed.some((value) => value !== key && lookupTableEstimate(value, { [key]: 1 }, true) !== undefined);
+    const unknown2 = keys.filter((key) => !allowed.includes(key) && !usedThroughMultiplier(key));
+    if (unknown2.length > 0) {
+      warnings.push({
+        path: "estimation.conversion.table",
+        message: `conversion.table ${unknown2.length === 1 ? "key" : "keys"} ${listValues(unknown2)} ${unknown2.length === 1 ? "is not an allowed value" : "are not allowed values"} of "${field.referenceName}" and will never match.`,
+        suggestion: `Allowed values: ${listValues(allowed)}.`
+      });
+    }
+  }
+  if (field.type === "string" && field.allowsCustomValues) {
+    const consequence = multipliers ? "any value that neither matches a conversion table key nor parses as a number followed by a key will leave Tasks unestimated." : "any value not in the conversion table will leave Tasks unestimated.";
+    warnings.push({
+      path: "estimation.source",
+      message: field.isPicklist ? `"${field.referenceName}" is a suggested picklist that also accepts values outside its list; ${consequence}` : `"${field.referenceName}" is a free-text field; ${consequence}`
+    });
+  }
+  if (field.type === "string") {
+    template.tasks.forEach((task, i2) => {
+      const conditions = [
+        [`tasks[${i2}].condition`, task.condition],
+        ...(task.estimationPercentCondition ?? []).map((rule, j2) => [`tasks[${i2}].estimationPercentCondition[${j2}].condition`, rule.condition])
+      ];
+      for (const [path, condition] of conditions) {
+        if (condition && usesNumericOperatorOnEstimation(condition)) {
+          warnings.push({
+            path,
+            message: `This condition compares estimation numerically, but "${field.referenceName}" holds text values; it will skip the task for any non-numeric Story Estimate.`,
+            suggestion: "Use equals or not-equals with the category values instead."
+          });
+        }
+      }
+    });
+  }
+}
+function usesNumericOperatorOnEstimation(condition) {
+  if ("all" in condition)
+    return condition.all.some(usesNumericOperatorOnEstimation);
+  if ("any" in condition)
+    return condition.any.some(usesNumericOperatorOnEstimation);
+  return "field" in condition && condition.field === "estimation" && NUMERIC_OPERATORS2.has(condition.operator);
+}
+function byReference(fields) {
+  return new Map(fields.map((field) => [field.referenceName, field]));
+}
+function listValues(values) {
+  return values.map((value) => `"${value}"`).join(", ");
+}
+var NUMERIC_TYPES, NUMERIC_OPERATORS2;
+var init_estimation_verifier = __esm(() => {
+  init_schema2();
+  NUMERIC_TYPES = new Set(["integer", "decimal"]);
+  NUMERIC_OPERATORS2 = new Set(["gt", "lt", "gte", "lte"]);
+});
+
 // ../atomize-core/src/templates/project-verifier.ts
 function analyzeTemplateProjectVerification(template) {
   const customFieldTaskCount = template.tasks.filter((task) => task.customFields && Object.keys(task.customFields).length > 0).length;
   const conditionFieldRefs = Array.from(new Set(template.tasks.flatMap((task) => task.condition ? extractCustomFieldRefs(task.condition) : [])));
   const hasSavedQuery = !!(template.filter?.savedQuery?.id || template.filter?.savedQuery?.path);
+  const hasEstimationMapping = hasEstimationMappingOverrides(template);
   return {
     customFieldTaskCount,
     conditionFieldRefs,
     hasSavedQuery,
-    needsOnlineVerification: customFieldTaskCount > 0 || conditionFieldRefs.length > 0 || hasSavedQuery
+    hasEstimationMapping,
+    needsOnlineVerification: customFieldTaskCount > 0 || conditionFieldRefs.length > 0 || hasSavedQuery || hasEstimationMapping
   };
 }
 async function verifyTemplateProject(template, options) {
@@ -89615,12 +90168,28 @@ async function verifyTemplateProject(template, options) {
     return result;
   }
   if ((requirements.customFieldTaskCount > 0 || requirements.conditionFieldRefs.length > 0) && options.platform?.getFieldSchemas) {
-    const customFields = await verifyTemplateCustomFields(template, options.platform.getFieldSchemas.bind(options.platform));
+    const customFields = await verifyTemplateCustomFields(template, options.platform.getFieldSchemas.bind(options.platform), template.taskType ?? options.platform.getEstimationDefaults?.().taskWorkItemType);
     result.errors.push(...customFields.errors);
     result.warnings.push(...customFields.warnings);
     if (customFields.errors.length > 0)
       result.valid = false;
   }
+  const platform = options.platform;
+  if (requirements.hasEstimationMapping && platform?.getFieldSchemas) {
+    const estimation = await verifyEstimationMapping(template, {
+      getFieldSchemas: platform.getFieldSchemas.bind(platform),
+      getWorkItemTypes: platform.getWorkItemTypes?.bind(platform),
+      getEstimationDefaults: platform.getEstimationDefaults?.bind(platform)
+    });
+    result.errors.push(...estimation.errors);
+    if (options.strict === true || template.validation?.mode === "strict") {
+      result.errors.push(...estimation.warnings.map((w2) => ({ path: w2.path, message: w2.message, suggestion: w2.suggestion, code: "STRICT_MODE_WARNING" })));
+    } else {
+      result.warnings.push(...estimation.warnings);
+    }
+    if (result.errors.length > 0)
+      result.valid = false;
+  }
   if (requirements.hasSavedQuery && options.platform?.listSavedQueries) {
     const savedQuery = await verifySavedQuery(template, options.platform);
     result.errors.push(...savedQuery.errors);
@@ -89676,6 +90245,7 @@ async function verifySavedQuery(template, platform) {
 var init_project_verifier = __esm(() => {
   init_condition_evaluator();
   init_custom_field_verifier();
+  init_estimation_verifier();
 });
 
 // ../atomize-core/src/templates/template-verification.ts
@@ -92800,6 +93370,25 @@ function assertNotCancelled(value) {
   }
   return value;
 }
+function parseConversionTable(input2) {
+  const entries = input2.split(",").map((entry) => entry.trim()).filter(Boolean);
+  if (entries.length === 0)
+    return "Enter at least one entry, e.g. S=2, M=4, L=5";
+  const table = {};
+  for (const entry of entries) {
+    const separator = entry.lastIndexOf("=");
+    const key = separator > 0 ? entry.slice(0, separator).trim() : "";
+    const value = Number(entry.slice(separator + 1).trim());
+    if (!key || separator === entry.length - 1 || Number.isNaN(value))
+      return `"${entry}" is not in the form value=amount`;
+    if (value < 0)
+      return `"${key}" cannot have a negative amount`;
+    if (Object.hasOwn(table, key))
+      return `"${key}" appears more than once`;
+    table[key] = value;
+  }
+  return table;
+}
 async function selectOrAutocomplete(opts) {
   const count = opts.thresholdCount ?? opts.options.length;
   if (count > AUTOCOMPLETE_THRESHOLD) {
@@ -92888,6 +93477,31 @@ 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))
+        return `${fieldName} must be a number`;
+      if (num <= 0)
+        return `${fieldName} must be greater than 0`;
+      return;
+    },
+    fieldReferenceName: (input2) => {
+      if (!input2 || input2.trim() === "")
+        return "Field reference name is required";
+      if (/\s/.test(input2.trim()))
+        return "Use the field's reference name (e.g. Custom.TShirtSize), which has no spaces";
+      return;
+    },
+    conversionTable: (input2) => {
+      const parsed = parseConversionTable(input2 ?? "");
+      return typeof parsed === "string" ? parsed : undefined;
+    },
     estimationPercent: (input2) => {
       const num = Number(input2);
       if (Number.isNaN(num))
@@ -93201,9 +93815,19 @@ var init_profile_resolver = __esm(() => {
   init_keychain_service();
 });
 
+// ../atomize-core/src/services/template/estimation-grounding.ts
+function isEstimateCapableField(field, rules) {
+  return isEstimateSourceField(field, rules);
+}
+var init_estimation_grounding = __esm(() => {
+  init_src();
+  init_src();
+});
+
 // src/cli/commands/template/template-wizard-helper.command.ts
 var exports_template_wizard_helper_command = {};
 __export(exports_template_wizard_helper_command, {
+  renderConversionTable: () => renderConversionTable,
   promptMixinRefs: () => promptMixinRefs,
   configureValidation: () => configureValidation,
   configureTemplateComposition: () => configureTemplateComposition,
@@ -93268,7 +93892,7 @@ async function configureFilter(ctx, defaults) {
     initialValue: defaultFilterMode
   }));
   if (filterMode === "savedQuery") {
-    return promptSavedQuery(ctx.savedQueries);
+    return promptSavedQuery(ctx, defaults);
   }
   const filter = {};
   const workItemTypes = await promptWorkItemTypes(ctx, defaults?.workItemTypes);
@@ -93353,8 +93977,8 @@ async function configureFilter(ctx, defaults) {
   }
   return filter;
 }
-async function promptSavedQuery(queries) {
-  const sorted = [...queries].sort((a3, b3) => {
+async function promptSavedQuery(ctx, defaults) {
+  const sorted = [...ctx.savedQueries].sort((a3, b3) => {
     if (a3.isPublic !== b3.isPublic)
       return a3.isPublic ? -1 : 1;
     return a3.path.localeCompare(b3.path);
@@ -93368,16 +93992,21 @@ async function promptSavedQuery(queries) {
     })),
     placeholder: "Type to filter by path or name..."
   });
+  const workItemTypes = await promptWorkItemTypes(ctx, defaults?.workItemTypes, {
+    message: "Which work item types does this query return? (used to look up their fields, not to filter)",
+    required: true
+  });
   const excludeIfHasTasks = assertNotCancelled(await confirm({
     message: "Exclude work items that already have tasks?",
     initialValue: true
   }));
   return {
     savedQuery: { id: selectedId.trim() },
+    workItemTypes,
     ...excludeIfHasTasks && { excludeIfHasTasks: true }
   };
 }
-async function promptWorkItemTypes(ctx, defaults) {
+async function promptWorkItemTypes(ctx, defaults, options = {}) {
   const defaultType = ctx.workItemTypes.includes("User Story") ? "User Story" : undefined;
   const sorted = [
     ...defaultType ? [defaultType] : [],
@@ -93385,10 +94014,10 @@ async function promptWorkItemTypes(ctx, defaults) {
   ];
   const initialValues = defaults && defaults.length > 0 ? defaults.filter((t3) => ctx.workItemTypes.includes(t3)) : defaultType ? [defaultType] : [];
   const selected = assertNotCancelled(await multiselect({
-    message: "Select work item types:",
+    message: options.message ?? "Select work item types:",
     options: sorted.map((t3) => ({ label: t3, value: t3 })),
     initialValues,
-    required: false
+    required: options.required ?? false
   }));
   return selected;
 }
@@ -93681,7 +94310,12 @@ async function promptDateFilter(selectMessage, customMessage, defaults) {
   }
   return choice;
 }
-async function configureEstimation(defaults) {
+async function configureEstimation(defaults, ctx = {}, currentTaskType) {
+  const source = await promptEstimationSource(defaults?.source, ctx);
+  const sourceField = source ? ctx.storyFields?.find((field) => field.referenceName === source) : undefined;
+  const conversion = await promptConversion(defaults?.conversion, sourceField);
+  const sourceValues = sourceField?.isPicklist ? sourceField.allowedValues ?? [] : [];
+  const { taskType, targetFields } = await promptEstimateTarget(currentTaskType, defaults?.targetFields, ctx);
   const rounding = assertNotCancelled(await select({
     message: "Rounding strategy:",
     options: [
@@ -93692,23 +94326,267 @@ async function configureEstimation(defaults) {
     ],
     initialValue: defaults?.rounding ?? "none"
   }));
-  const minimumTaskPointsRaw = assertNotCancelled(await text({
-    message: "Minimum task points (0 for no minimum):",
-    initialValue: String(defaults?.minimumTaskPoints ?? 0),
-    validate: (input2) => {
-      const n4 = Number(input2);
-      if (Number.isNaN(n4))
-        return "Must be a valid number";
-      if (n4 < 0)
-        return "Cannot be negative";
-      return;
-    }
+  const minimumTaskEstimateRaw = assertNotCancelled(await text({
+    message: "Minimum Task Estimate, in the Task's unit (0 for no minimum):",
+    initialValue: String(defaults?.minimumTaskEstimate ?? defaults?.minimumTaskPoints ?? 0),
+    validate: Validators.nonNegative("Minimum Task Estimate")
   }));
-  return {
+  const normalize = assertNotCancelled(await select({
+    message: "When the generated tasks' percentages don't add up to 100%:",
+    options: [
+      { label: "Fill up to 100% (scale up below 100%, keep anything above)", value: "auto" },
+      { label: "Always scale to exactly 100%", value: "always" },
+      { label: "Use the percentages as written", value: "never" }
+    ],
+    initialValue: defaults?.normalize ?? "auto"
+  }));
+  const policy = assertNotCancelled(await select({
+    message: "When a Story's estimate is missing or can't be converted:",
+    options: [
+      { label: "Create the tasks with blank estimates and warn", value: "warn" },
+      { label: "Skip the Story", value: "skip" },
+      { label: "Assume a default Story Estimate", value: "use-default" }
+    ],
+    initialValue: defaults?.ifParentHasNoEstimation ?? "warn"
+  }));
+  const defaultParentEstimation = policy === "use-default" ? await promptDefaultStoryEstimate(defaults?.defaultParentEstimation, conversion, sourceValues) : undefined;
+  const {
+    source: _source,
+    conversion: _conversion,
+    targetFields: _targetFields,
+    minimumTaskPoints: _minimumTaskPoints,
+    defaultParentEstimation: _default3,
+    ifParentHasNoEstimation: _policy,
+    normalize: _normalize2,
+    ...kept
+  } = defaults ?? {};
+  const estimation = {
+    ...kept,
     strategy: "percentage",
     rounding,
-    minimumTaskPoints: Number(minimumTaskPointsRaw) || undefined
-  };
+    minimumTaskEstimate: Number(minimumTaskEstimateRaw) || undefined,
+    ...source ? { source } : {},
+    ...conversion ? { conversion } : {},
+    ...targetFields?.length ? { targetFields } : {},
+    ...normalize !== "auto" ? { normalize } : {},
+    ...policy !== "warn" ? { ifParentHasNoEstimation: policy } : {},
+    ...defaultParentEstimation !== undefined ? { defaultParentEstimation } : {}
+  };
+  if (estimation.minimumTaskEstimate === undefined)
+    delete estimation.minimumTaskEstimate;
+  return { estimation, ...taskType ? { taskType } : {} };
+}
+async function promptEstimationSource(current, ctx) {
+  const rules = { storyEstimateFields: ctx.defaults?.storyEstimateFields ?? [], nonEstimateFields: ctx.defaults?.nonEstimateFields };
+  const candidates = sortEstimateFields((ctx.storyFields ?? []).filter((field) => isEstimateCapableField(field, rules)));
+  if (ctx.storyFields !== undefined) {
+    const choice = assertNotCancelled(await select({
+      message: "Which Story field holds the Story Estimate?",
+      options: [
+        { label: "Platform default (story points, effort or size)", value: "" },
+        ...candidates.map((field) => ({
+          label: `${field.name} (${field.referenceName})`,
+          value: field.referenceName,
+          hint: field.isPicklist ? `values: ${(field.allowedValues ?? []).join(", ")}` : field.type
+        })),
+        { label: "Another field (enter its reference name)", value: CUSTOM_ENTRY }
+      ],
+      initialValue: current && candidates.some((field) => field.referenceName === current) ? current : current ? CUSTOM_ENTRY : ""
+    }));
+    if (choice !== CUSTOM_ENTRY)
+      return choice || undefined;
+  }
+  const typed = assertNotCancelled(await text({
+    message: "Story field reference name holding the Story Estimate (leave blank for the platform default):",
+    initialValue: current ?? "",
+    validate: (input2) => input2 && input2.trim() !== "" ? Validators.fieldReferenceName(input2) : undefined
+  }));
+  return typed.trim() || undefined;
+}
+async function promptConversion(current, sourceField) {
+  const kind = assertNotCancelled(await select({
+    message: "How does the Story Estimate translate into Task hours?",
+    options: [
+      { label: "One-to-one (use the number as it is)", value: "none" },
+      { label: "A factor (e.g. 1 point = 4 hours)", value: "factor" },
+      { label: "A table (e.g. t-shirt sizes, or points that don't scale linearly)", value: "table" }
+    ],
+    initialValue: current?.table ? "table" : current?.factor !== undefined ? "factor" : sourceField?.isPicklist ? "table" : "none"
+  }));
+  if (kind === "none")
+    return;
+  if (kind === "factor") {
+    const factor = assertNotCancelled(await text({
+      message: "Task hours per unit of Story Estimate:",
+      initialValue: current?.factor !== undefined ? String(current.factor) : "",
+      validate: Validators.positiveNumber("Factor")
+    }));
+    return { factor: Number(factor) };
+  }
+  const table = await promptConversionTable(current?.table, sourceField);
+  const keysAreCategories = !Object.keys(table).every((key) => /^(?:\d+(?:\.\d+)?|\.\d+)$/.test(key));
+  const multipliers = keysAreCategories && assertNotCancelled(await confirm({
+    message: "Also accept multiples of a size, e.g. 0.3XL = 0.3 × XL?",
+    initialValue: current?.multipliers === true
+  }));
+  return { table, ...multipliers ? { multipliers: true } : {} };
+}
+function renderConversionTable(table, source) {
+  const allowed = source?.allowedValues ?? [];
+  const entries = Object.entries(table);
+  const heading = `Conversion table — ${source?.name ?? "Story Estimate"} → hours`;
+  const lines = [allowed.length ? `${heading}   ${allowed.filter((v2) => Object.hasOwn(table, v2)).length} of ${allowed.length} values covered` : heading];
+  if (entries.length === 0) {
+    lines.push("  (no values yet)");
+  } else {
+    const width = Math.max(5, ...entries.map(([key]) => key.length));
+    lines.push(`  ${"Value".padEnd(width)}  ${"Hours".padEnd(6)}  A 20% task gets`);
+    for (const [key, hours] of entries) {
+      const flag = allowed.length && !allowed.includes(key) ? "   not in picklist" : "";
+      lines.push(`  ${key.padEnd(width)}  ${String(hours).padEnd(6)}  ${Math.round(hours * 20) / 100} h${flag}`);
+    }
+  }
+  const missing = allowed.filter((value) => !Object.hasOwn(table, value));
+  if (missing.length)
+    lines.push(`  Missing: ${missing.join(", ")} — Stories with ${missing.length === 1 ? "this value" : "these values"} get blank estimates.`);
+  return lines;
+}
+async function promptConversionTable(current, sourceField) {
+  const allowed = sourceField?.isPicklist ? sourceField.allowedValues ?? [] : [];
+  const table = { ...current ?? {} };
+  if (allowed.length && !current) {
+    output3.print(source_default.gray(`Enter the Task hours for each ${sourceField?.name ?? "value"}. Leave blank to skip a value.`));
+    for (const [index, value] of allowed.entries()) {
+      const hours = assertNotCancelled(await text({
+        message: `Hours for "${value}" (${index + 1} of ${allowed.length}):`,
+        validate: (input2) => input2 && input2.trim() !== "" ? Validators.nonNegative("Hours")(input2) : undefined
+      }));
+      if (hours.trim() !== "")
+        table[value] = Number(hours);
+    }
+  }
+  for (;; ) {
+    output3.blankLine();
+    for (const line of renderConversionTable(table, sourceField))
+      output3.print(source_default.gray(line));
+    const missing = allowed.filter((value) => !Object.hasOwn(table, value));
+    const keys = Object.keys(table);
+    const action = assertNotCancelled(await select({
+      message: "Conversion table",
+      options: [
+        ...missing.map((value) => ({ label: `Add hours for ${value}`, value: `add:${value}` })),
+        { label: allowed.length ? "Add another value…" : "Add a value", value: "add" },
+        ...keys.length ? [{ label: "Change a value's hours", value: "change" }, { label: "Remove a value", value: "remove" }] : [],
+        { label: "Paste several (e.g. S=2, M=4)", value: "paste" },
+        { label: "Done", value: "done" }
+      ],
+      initialValue: missing.length ? `add:${missing[0]}` : keys.length ? "done" : "add"
+    }));
+    if (action === "done") {
+      if (keys.length)
+        return table;
+      output3.print(source_default.yellow("Add at least one value before finishing."));
+      continue;
+    }
+    if (action.startsWith("add:")) {
+      const value = action.slice(4);
+      table[value] = Number(assertNotCancelled(await text({ message: `Hours for "${value}":`, validate: hoursValidator })));
+      continue;
+    }
+    if (action === "add") {
+      const value = assertNotCancelled(await text({
+        message: "Story Estimate value (e.g. XL, or 8 for points):",
+        validate: (input2) => {
+          if (!input2 || input2.trim() === "")
+            return "Enter a value";
+          if (Object.hasOwn(table, input2.trim()))
+            return `"${input2.trim()}" is already in the table`;
+          return;
+        }
+      })).trim();
+      table[value] = Number(assertNotCancelled(await text({ message: `Hours for "${value}":`, validate: hoursValidator })));
+      continue;
+    }
+    if (action === "change") {
+      const value = assertNotCancelled(await select({ message: "Which value?", options: keys.map((key) => ({ label: `${key} (${table[key]} h)`, value: key })) }));
+      table[value] = Number(assertNotCancelled(await text({ message: `Hours for "${value}":`, initialValue: String(table[value]), validate: hoursValidator })));
+      continue;
+    }
+    if (action === "remove") {
+      const value = assertNotCancelled(await select({ message: "Remove which value?", options: keys.map((key) => ({ label: `${key} (${table[key]} h)`, value: key })) }));
+      delete table[value];
+      continue;
+    }
+    const pasted = assertNotCancelled(await text({ message: "Value=hours pairs, comma-separated (e.g. S=2, M=4, L=5):", validate: Validators.conversionTable }));
+    Object.assign(table, parseConversionTable(pasted));
+  }
+}
+async function promptEstimateTarget(currentTaskType, currentTargetFields, ctx) {
+  const customise = assertNotCancelled(await confirm({
+    message: `Create tasks as a different work item type, or write estimates to different fields? (default: ${ctx.defaults?.taskWorkItemType ?? "platform default"})`,
+    initialValue: currentTaskType !== undefined || (currentTargetFields?.length ?? 0) > 0
+  }));
+  if (!customise)
+    return {};
+  const defaultType = ctx.defaults?.taskWorkItemType;
+  let taskType;
+  if (ctx.workItemTypes?.length) {
+    taskType = assertNotCancelled(await select({
+      message: "Work item type to create tasks as:",
+      options: ctx.workItemTypes.map((type) => ({ label: type, value: type, hint: type === defaultType ? "platform default" : undefined })),
+      initialValue: currentTaskType ?? defaultType ?? ctx.workItemTypes[0]
+    }));
+  } else {
+    taskType = assertNotCancelled(await text({
+      message: "Work item type to create tasks as:",
+      initialValue: currentTaskType ?? defaultType ?? "",
+      validate: Validators.required("Work item type")
+    })).trim();
+  }
+  const numericFields = ctx.getTaskFields ? sortEstimateFields((await ctx.getTaskFields(taskType)).filter((field) => isEstimateTargetField(field, ctx.defaults))) : [];
+  let targetFields;
+  if (numericFields.length > 0) {
+    targetFields = assertNotCancelled(await multiselect({
+      message: "Task fields that receive the estimate (none selected = platform default fields):",
+      options: numericFields.map((field) => ({ label: `${field.name} (${field.referenceName})`, value: field.referenceName })),
+      initialValues: currentTargetFields ?? [],
+      required: false
+    }));
+  } else {
+    const typed = assertNotCancelled(await text({
+      message: "Task field reference names that receive the estimate, comma-separated (blank = platform default fields):",
+      initialValue: currentTargetFields?.join(", ") ?? ""
+    }));
+    targetFields = Filters.commaSeparated(typed).filter(Boolean);
+  }
+  const keepTaskType = taskType !== defaultType || currentTaskType !== undefined;
+  return { ...keepTaskType ? { taskType } : {}, ...targetFields.length ? { targetFields } : {} };
+}
+async function promptDefaultStoryEstimate(current, conversion, sourceValues) {
+  const choices = (sourceValues.length ? sourceValues : Object.keys(conversion?.table ?? {})).filter((value) => isConvertibleStoryEstimate(value, conversion));
+  if (choices.length > 0) {
+    const currentValue = current === undefined ? undefined : String(current);
+    const choice = assertNotCancelled(await select({
+      message: "Default Story Estimate to assume:",
+      options: [
+        ...choices.map((value) => ({ label: value, value })),
+        ...conversion?.multipliers ? [{ label: "Another value (e.g. 0.5L)", value: CUSTOM_ENTRY }] : []
+      ],
+      initialValue: currentValue && choices.includes(currentValue) ? currentValue : currentValue && conversion?.multipliers ? CUSTOM_ENTRY : choices[0]
+    }));
+    if (choice !== CUSTOM_ENTRY)
+      return choice;
+  }
+  const typed = assertNotCancelled(await text({
+    message: "Default Story Estimate to assume (e.g. 5, or a size like M):",
+    initialValue: current !== undefined ? String(current) : "",
+    validate: (input2) => {
+      if (!input2 || input2.trim() === "")
+        return "A default Story Estimate is required";
+      return isConvertibleStoryEstimate(input2.trim(), conversion) ? undefined : conversion?.table ? "Must be a value of the conversion table, or a multiple of one" : "Must be a number unless a conversion table is set";
+    }
+  })).trim();
+  return Number.isFinite(Number(typed)) ? Number(typed) : typed;
 }
 async function configureValidation(defaults) {
   const validation = {};
@@ -93953,9 +94831,15 @@ async function promptMixinRefs(mixins) {
 function formatCatalogChoice(item) {
   return `${item.displayName} (${item.scope})`;
 }
-var output3, ADVANCED_GROUP_ORDER, DATE_FILTER_OPTIONS;
+var output3, ADVANCED_GROUP_ORDER, DATE_FILTER_OPTIONS, CUSTOM_ENTRY = "__custom__", hoursValidator = (input2) => {
+  if (!input2 || input2.trim() === "")
+    return "Enter the hours";
+  return Validators.nonNegative("Hours")(input2);
+};
 var init_template_wizard_helper_command = __esm(() => {
   init_dist6();
+  init_estimation_grounding();
+  init_schema2();
   init_source();
   init_command_output();
   init_prompt_utilities();
@@ -97894,7 +98778,7 @@ var program = new Command;
 
 // package.json
 var name = "@sppg2001/atomize";
-var version2 = "4.0.1";
+var version2 = "4.2.0";
 
 // src/cli/commands/auth/auth-add.command.ts
 init_dist6();
@@ -98850,6 +99734,7 @@ init_dist6();
 init_logger2();
 init_estimation_distribution();
 init_platform_factory();
+init_schema2();
 init_template_library();
 init_errors();
 
@@ -99396,16 +100281,26 @@ function printReport(report, options, dryRun, storyIds) {
 `));
     for (const result of report.results) {
       if (result.success) {
+        if (result.skipReason) {
+          output2.print(source_default.yellow(`⊘ ${sanitizeTty(result.story.id)}: ${sanitizeTty(result.story.title)}`));
+          output2.print(source_default.gray(`  Skipped: ${sanitizeTty(result.skipReason)}`));
+          continue;
+        }
         output2.print(source_default.green(`✓ ${sanitizeTty(result.story.id)}: ${sanitizeTty(result.story.title)}`));
-        output2.print(source_default.gray(`  Estimation: ${result.story.estimation || 0} points`));
+        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)})` : "";
+        output2.print(source_default.gray(`  Estimation: ${rawEstimate === undefined ? "none" : sanitizeTty(String(rawEstimate))}${conversionNote}`));
         output2.print(source_default.gray(`  Tasks: ${result.tasksCalculated.length}`));
         if (result.estimationSummary) {
-          output2.print(source_default.gray(`  Distribution: ${result.estimationSummary.totalTaskEstimation} points (${result.estimationSummary.percentageUsed.toFixed(0)}%)`));
+          output2.print(source_default.gray(`  Distribution: ${withUnit(result.estimationSummary.totalTaskEstimation)} (${result.estimationSummary.percentageUsed.toFixed(0)}%)`));
         }
         if ((options.verbose || dryRun) && result.tasksCalculated.length > 0) {
           output2.print(source_default.gray("  Task breakdown:"));
           for (const task of result.tasksCalculated) {
-            output2.print(source_default.gray(`    - ${sanitizeTty(task.title)}: ${task.estimation} points (${task.estimationPercent}%)`));
+            const estimate = task.estimation === undefined ? "unestimated" : withUnit(task.estimation);
+            output2.print(source_default.gray(`    - ${sanitizeTty(task.title)}: ${estimate} (${task.estimationPercent}%)`));
           }
         }
       } else {
@@ -99577,6 +100472,8 @@ function makeGenerateCommand(makeOutput, prompts, config2) {
   });
 }
 async function resolveNormalization(template, isTTYSession, prompts) {
+  if (template.estimation?.normalize && template.estimation.normalize !== "auto")
+    return false;
   const { shouldOffer, total } = shouldOfferOverageNormalization(template.tasks);
   if (!shouldOffer)
     return false;
@@ -99594,6 +100491,7 @@ async function resolveNormalization(template, isTTYSession, prompts) {
 init_condition_evaluator();
 init_dependency_resolver();
 init_estimation_calculator();
+init_mock_adapter();
 var STANDARD_FIELD_TYPES = {
   id: "string",
   title: "string",
@@ -99652,7 +100550,11 @@ function inspectTemplate(template) {
     }
   }
   if (template.tasks.some((task) => task.estimationPercent !== undefined || task.estimationPercentCondition?.length)) {
-    upsert("estimation", "number", "estimation", { required: true });
+    const source = template.estimation?.source;
+    if (source)
+      upsert(source, "unknown", "estimation", { required: true });
+    else
+      upsert("estimation", "number", "estimation", { required: true });
   }
   for (const name2 of filterFields) {
     upsert(name2, STANDARD_FIELD_TYPES[name2] ?? "unknown", "filter");
@@ -99695,13 +100597,16 @@ function runPreview(template, mockStoryJson) {
   const story = parseMockStory(mockStoryJson);
   const orderedTasks = new DependencyResolver().resolveDependencies(template.tasks);
   const calc = new EstimationCalculator;
-  const { calculatedTasks, skippedTasks } = calc.calculateTasksWithSkipped(story, "", orderedTasks, template.estimation);
-  const summary = calc.getEstimationSummary(story, calculatedTasks);
+  const fieldMapping = resolveEstimationFieldMapping(MOCK_ESTIMATION_DEFAULTS, {
+    source: template.estimation?.source,
+    targetFields: template.estimation?.targetFields
+  });
+  const { calculatedTasks, skippedTasks, unresolvedEstimate } = calc.calculateTasksWithSkipped(story, "", orderedTasks, template.estimation, false, fieldMapping);
+  const summary = calc.getEstimationSummary(story, calculatedTasks, template.estimation, fieldMapping);
   const tasks = calculatedTasks.map((task) => {
-    const result = {
-      title: task.title,
-      estimation: task.estimation ?? 0
-    };
+    const result = { title: task.title };
+    if (task.estimation !== undefined)
+      result.estimation = task.estimation;
     if (task.estimationPercent !== undefined)
       result.estimationPercent = task.estimationPercent;
     if (task.dependsOn?.length)
@@ -99720,6 +100625,8 @@ function runPreview(template, mockStoryJson) {
       title: s2.templateTask.title,
       reason: s2.reason
     })),
+    ...unresolvedEstimate ? { unresolvedEstimate } : {},
+    ...fieldMapping.unitLabel ? { estimateUnit: fieldMapping.unitLabel } : {},
     estimationSummary: {
       storyEstimation: summary.storyEstimation,
       totalTaskEstimation: summary.totalTaskEstimation,
@@ -100041,6 +100948,70 @@ init_errors();
 // ../atomize-core/src/services/template/learned-template-product.ts
 init_estimation_distribution();
 
+// ../atomize-core/src/core/estimation-inference.ts
+function taskEstimateShares(taskEstimates) {
+  const total = taskEstimates.reduce((sum, value) => sum + (value ?? 0), 0);
+  if (total <= 0)
+    return taskEstimates.map(() => 0);
+  return taskEstimates.map((value) => Math.round((value ?? 0) / total * 100));
+}
+function inferEstimation(samples) {
+  const usable = samples.map((sample) => ({ estimate: sample.storyEstimate, total: sum(sample.taskEstimates) })).filter((s2) => s2.estimate !== undefined && s2.total > 0);
+  if (usable.length === 0)
+    return { lowConfidenceValues: [] };
+  const defaultStoryEstimate = mostCommon(usable.map((s2) => s2.estimate));
+  const allNumeric = usable.every((s2) => numericStoryEstimate(s2.estimate) !== undefined);
+  if (allNumeric) {
+    const ratios = usable.map((s2) => ({ points: numericStoryEstimate(s2.estimate) ?? 0, total: s2.total })).filter((s2) => s2.points > 0).map((s2) => s2.total / s2.points);
+    if (ratios.length === 0)
+      return { defaultStoryEstimate, lowConfidenceValues: [] };
+    const factor = roundTo(median(ratios), 2);
+    return {
+      ...factor !== 1 ? { conversion: { factor } } : {},
+      defaultStoryEstimate,
+      lowConfidenceValues: []
+    };
+  }
+  const totalsByValue = new Map;
+  for (const s2 of usable) {
+    const key = String(s2.estimate).trim();
+    totalsByValue.set(key, [...totalsByValue.get(key) ?? [], s2.total]);
+  }
+  const table = {};
+  const lowConfidenceValues = [];
+  for (const [key, totals] of totalsByValue) {
+    table[key] = roundTo(median(totals), 2);
+    if (totals.length === 1)
+      lowConfidenceValues.push(key);
+  }
+  return { conversion: { table }, defaultStoryEstimate, lowConfidenceValues };
+}
+function sum(values) {
+  return values.reduce((total, value) => total + (value ?? 0), 0);
+}
+function median(values) {
+  const sorted = [...values].sort((a3, b3) => a3 - b3);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? ((sorted[mid - 1] ?? 0) + (sorted[mid] ?? 0)) / 2 : sorted[mid] ?? 0;
+}
+function mostCommon(values) {
+  const counts = new Map;
+  for (const value of values)
+    counts.set(value, (counts.get(value) ?? 0) + 1);
+  let best;
+  let bestCount = 0;
+  for (const [value, count] of counts) {
+    if (count > bestCount) {
+      best = value;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+function roundTo(value, decimals) {
+  const scale = 10 ** decimals;
+  return Math.round(value * scale) / scale;
+}
 // ../atomize-core/src/services/template/pattern-detection.ts
 init_dist();
 var DEFAULT_PATTERN_SCORING_CONFIG = {
@@ -100631,12 +101602,12 @@ class ConditionPatternDetector {
   }
   detectEstimationConditions(analyses, commonTasks, threshold) {
     const patterns = [];
-    const estimations = analyses.map((a3) => a3.story.estimation).filter((e2) => e2 !== undefined && e2 > 0).sort((a3, b3) => a3 - b3);
+    const estimations = analyses.map((a3) => numericStoryEstimate(a3.story.estimation)).filter((e2) => e2 !== undefined && e2 > 0).sort((a3, b3) => a3 - b3);
     if (estimations.length < this.minSampleSize)
       return patterns;
-    const median = estimations[Math.floor(estimations.length / 2)] ?? 0;
-    const q75 = estimations[Math.floor(estimations.length * 3 / 4)] ?? median;
-    const thresholds = [...new Set([median, q75])].filter((t3) => t3 > 0);
+    const median2 = estimations[Math.floor(estimations.length / 2)] ?? 0;
+    const q75 = estimations[Math.floor(estimations.length * 3 / 4)] ?? median2;
+    const thresholds = [...new Set([median2, q75])].filter((t3) => t3 > 0);
     for (const commonTask of commonTasks) {
       if (commonTask.frequencyRatio >= 0.9)
         continue;
@@ -100666,7 +101637,7 @@ class ConditionPatternDetector {
     let taskInLargeStories = 0;
     let taskInSmallStories = 0;
     for (const analysis of analyses) {
-      const estimation = analysis.story.estimation;
+      const estimation = numericStoryEstimate(analysis.story.estimation);
       if (estimation === undefined)
         continue;
       const isLarge = estimation >= estimationThreshold;
@@ -100779,7 +101750,7 @@ class ConditionPatternDetector {
           return false;
         }
         case "estimation": {
-          const e2 = story.estimation;
+          const e2 = numericStoryEstimate(story.estimation);
           if (e2 === undefined)
             return false;
           const v2 = condition.value;
@@ -100950,18 +101921,18 @@ class FilterLearner {
     for (const p3 of priorities) {
       priorityCounts.set(p3, (priorityCounts.get(p3) ?? 0) + 1);
     }
-    let mostCommon = min;
+    let mostCommon2 = min;
     let maxCount = 0;
     for (const [priority, count] of priorityCounts) {
       if (count > maxCount) {
-        mostCommon = priority;
+        mostCommon2 = priority;
         maxCount = count;
       }
     }
-    return { min, max, mostCommon };
+    return { min, max, mostCommon: mostCommon2 };
   }
   detectEstimationRange(analyses) {
-    const estimations = analyses.map((a3) => a3.story.estimation).filter((e2) => e2 !== undefined && e2 > 0);
+    const estimations = analyses.map((a3) => numericStoryEstimate(a3.story.estimation)).filter((e2) => e2 !== undefined && e2 > 0);
     if (estimations.length === 0)
       return;
     const sorted = [...estimations].sort((a3, b3) => a3 - b3);
@@ -101042,7 +102013,7 @@ class FilterLearner {
       if (max - min <= 3) {
         suggestions.push({
           type: "improve-filter",
-          message: `Stories have similar estimations (${min}-${max} points, avg ${average}). This template works well for stories of this size.`,
+          message: `Stories have similar estimations (${min}-${max}, avg ${average}). This template works well for stories of this size.`,
           severity: "info"
         });
       }
@@ -101065,8 +102036,8 @@ class FilterLearner {
       parts.push(`Area paths: ${learnedFilters.areaPaths.values.join(", ")}`);
     }
     if (learnedFilters.priorityRange) {
-      const { min, max, mostCommon } = learnedFilters.priorityRange;
-      parts.push(`Priority range: ${min}-${max} (most common: ${mostCommon})`);
+      const { min, max, mostCommon: mostCommon2 } = learnedFilters.priorityRange;
+      parts.push(`Priority range: ${min}-${max} (most common: ${mostCommon2})`);
     }
     if (learnedFilters.estimationRange) {
       const { min, max, average } = learnedFilters.estimationRange;
@@ -101215,7 +102186,7 @@ class PatternDetector extends SimilarityCalculator {
   detectEstimationPattern(analyses) {
     const totalEstimations = [];
     for (const analysis of analyses) {
-      const storyEstimation = analysis.story.estimation ?? 0;
+      const storyEstimation = numericStoryEstimate(analysis.story.estimation) ?? 0;
       totalEstimations.push(storyEstimation);
     }
     const avgTotal = totalEstimations.length > 0 ? totalEstimations.reduce((a3, b3) => a3 + b3, 0) / totalEstimations.length : 0;
@@ -101297,7 +102268,7 @@ class ConfidenceScorer {
     };
   }
   scoreTaskConsistency(analyses, patterns) {
-    const totalTasks = analyses.reduce((sum, a3) => sum + a3.tasks.length, 0);
+    const totalTasks = analyses.reduce((sum2, a3) => sum2 + a3.tasks.length, 0);
     if (totalTasks === 0) {
       return {
         name: "Task Consistency",
@@ -101377,9 +102348,9 @@ class ConfidenceScorer {
         description: "No tasks to merge"
       };
     }
-    const totalOriginalTasks = analyses.reduce((sum, a3) => sum + a3.tasks.length, 0);
+    const totalOriginalTasks = analyses.reduce((sum2, a3) => sum2 + a3.tasks.length, 0);
     const mergeRatio = totalOriginalTasks > 0 ? 1 - mergedTasks.length / totalOriginalTasks : 0;
-    const avgSimilarity = mergedTasks.reduce((sum, m3) => sum + m3.similarity, 0) / mergedTasks.length;
+    const avgSimilarity = mergedTasks.reduce((sum2, m3) => sum2 + m3.similarity, 0) / mergedTasks.length;
     const compositeScore = mergeRatio * 0.6 + avgSimilarity * 0.4;
     const score = Math.round(compositeScore * 100);
     return {
@@ -101418,7 +102389,7 @@ class ConfidenceScorer {
         description: "No dependency patterns detected"
       };
     }
-    const avgConfidence = dependencyPatterns.reduce((sum, d2) => sum + d2.confidence, 0) / dependencyPatterns.length;
+    const avgConfidence = dependencyPatterns.reduce((sum2, d2) => sum2 + d2.confidence, 0) / dependencyPatterns.length;
     const explicitCount = dependencyPatterns.filter((d2) => d2.source === "explicit").length;
     const explicitRatio = explicitCount / dependencyPatterns.length;
     const explicitBonus = explicitRatio * 10;
@@ -101440,8 +102411,8 @@ class ConfidenceScorer {
         description: "No conditional patterns detected"
       };
     }
-    const avgConfidence = conditionalPatterns.reduce((sum, c4) => sum + c4.confidence, 0) / conditionalPatterns.length;
-    const avgCoverage = conditionalPatterns.reduce((sum, c4) => sum + (c4.totalStories > 0 ? c4.matchCount / c4.totalStories : 0), 0) / conditionalPatterns.length;
+    const avgConfidence = conditionalPatterns.reduce((sum2, c4) => sum2 + c4.confidence, 0) / conditionalPatterns.length;
+    const avgCoverage = conditionalPatterns.reduce((sum2, c4) => sum2 + (c4.totalStories > 0 ? c4.matchCount / c4.totalStories : 0), 0) / conditionalPatterns.length;
     const score = Math.round(Math.min(100, avgConfidence * 70 + avgCoverage * 30));
     return {
       name: "Condition Quality",
@@ -101451,7 +102422,7 @@ class ConfidenceScorer {
     };
   }
   calculateOverall(factors, sampleCount) {
-    const baseScore = factors.reduce((sum, f2) => sum + f2.score * f2.weight, 0);
+    const baseScore = factors.reduce((sum2, f2) => sum2 + f2.score * f2.weight, 0);
     const extraWeightMap = {
       1: 0.5,
       2: 0.25,
@@ -101505,35 +102476,35 @@ class OutlierDetector {
     const sorted = [...values].sort((a3, b3) => a3 - b3);
     const n4 = sorted.length;
     const midIndex = Math.floor(n4 / 2);
-    const median = n4 % 2 === 1 ? sorted[midIndex] ?? 0 : ((sorted[midIndex - 1] ?? 0) + (sorted[midIndex] ?? 0)) / 2;
-    const deviations = values.map((v2) => Math.abs(v2 - median));
+    const median2 = n4 % 2 === 1 ? sorted[midIndex] ?? 0 : ((sorted[midIndex - 1] ?? 0) + (sorted[midIndex] ?? 0)) / 2;
+    const deviations = values.map((v2) => Math.abs(v2 - median2));
     const sortedDev = [...deviations].sort((a3, b3) => a3 - b3);
     const mad = n4 % 2 === 1 ? sortedDev[midIndex] ?? 0 : ((sortedDev[midIndex - 1] ?? 0) + (sortedDev[midIndex] ?? 0)) / 2;
-    return { median, mad };
+    return { median: median2, mad };
   }
-  modifiedZScore(value, median, mad) {
+  modifiedZScore(value, median2, mad) {
     if (mad === 0)
       return 0;
-    return this.madToStdDev * (value - median) / mad;
+    return this.madToStdDev * (value - median2) / mad;
   }
   detectEstimationOutliers(analyses) {
     const estimations = analyses.map((a3) => ({
       storyId: a3.story.id,
-      estimation: a3.story.estimation ?? 0
+      estimation: numericStoryEstimate(a3.story.estimation) ?? 0
     })).filter((e2) => e2.estimation > 0);
     if (estimations.length < 2)
       return [];
     const values = estimations.map((e2) => e2.estimation);
-    const { median, mad } = this.calculateMAD(values);
+    const { median: median2, mad } = this.calculateMAD(values);
     if (mad === 0)
       return [];
     const outliers = [];
     for (const e2 of estimations) {
-      const zScore = this.modifiedZScore(e2.estimation, median, mad);
+      const zScore = this.modifiedZScore(e2.estimation, median2, mad);
       const absZ = Math.abs(zScore);
       if (absZ > this.zThreshold) {
-        const expectedLower = median - this.zThreshold * mad / this.madToStdDev;
-        const expectedUpper = median + this.zThreshold * mad / this.madToStdDev;
+        const expectedLower = median2 - this.zThreshold * mad / this.madToStdDev;
+        const expectedUpper = median2 + this.zThreshold * mad / this.madToStdDev;
         outliers.push({
           type: "estimation",
           storyId: e2.storyId,
@@ -101557,16 +102528,16 @@ class OutlierDetector {
     if (counts.length < 2)
       return [];
     const values = counts.map((c4) => c4.count);
-    const { median, mad } = this.calculateMAD(values);
+    const { median: median2, mad } = this.calculateMAD(values);
     if (mad === 0)
       return [];
     const outliers = [];
     for (const c4 of counts) {
-      const zScore = this.modifiedZScore(c4.count, median, mad);
+      const zScore = this.modifiedZScore(c4.count, median2, mad);
       const absZ = Math.abs(zScore);
       if (absZ > this.zThreshold) {
-        const expectedLower = median - this.zThreshold * mad / this.madToStdDev;
-        const expectedUpper = median + this.zThreshold * mad / this.madToStdDev;
+        const expectedLower = median2 - this.zThreshold * mad / this.madToStdDev;
+        const expectedUpper = median2 + this.zThreshold * mad / this.madToStdDev;
         outliers.push({
           type: "task-count",
           storyId: c4.storyId,
@@ -101626,7 +102597,7 @@ class OutlierDetector {
 
 // ../atomize-core/src/services/template/learned-template-product.ts
 class LearnedTemplateProductBuilder {
-  buildMergedTemplate(analyses, mergedTasks) {
+  buildMergedTemplate(analyses, mergedTasks, estimationSource) {
     const taskDefinitions = mergedTasks.map((mt) => {
       const task = { ...mt.task };
       if (mt.learnedDependsOn && mt.learnedDependsOn.length > 0) {
@@ -101647,8 +102618,6 @@ class LearnedTemplateProductBuilder {
     normalizeLearnedTaskPercentages(taskDefinitions);
     const workItemTypes = [...new Set(analyses.map((a3) => a3.story.type))];
     const allTags = [...new Set(analyses.flatMap((a3) => a3.story.tags ?? []))];
-    const estimations = analyses.map((a3) => a3.story.estimation ?? 0).filter((estimation) => estimation > 0);
-    const avgEstimation = estimations.length > 0 ? Math.round(estimations.reduce((sum, estimation) => sum + estimation, 0) / estimations.length) : 0;
     const storyIds = analyses.map((a3) => a3.story.id).join(", ");
     return {
       version: "1.0",
@@ -101662,12 +102631,7 @@ class LearnedTemplateProductBuilder {
         tags: allTags.length > 0 ? { include: allTags } : undefined
       },
       tasks: taskDefinitions,
-      estimation: {
-        strategy: "percentage",
-        rounding: "none",
-        minimumTaskPoints: 0,
-        defaultParentEstimation: avgEstimation
-      }
+      estimation: learnedEstimationConfig(analyses.map((a3) => estimationSample(a3.story, a3.tasks)), estimationSource)
     };
   }
   buildEmptyTemplate(story) {
@@ -101688,11 +102652,10 @@ class LearnedTemplateProductBuilder {
       }
     };
   }
-  buildSingleStoryTemplate(story, tasks) {
-    const storyEstimation = story.estimation || 0;
+  buildSingleStoryTemplate(story, tasks, estimationSource) {
+    const shares = taskEstimateShares(tasks.map((task) => numericStoryEstimate(task.estimation)));
     const taskDefinitions = tasks.map((task, index) => {
-      const taskEstimation = task.estimation || 0;
-      const estimationPercent = storyEstimation > 0 ? Math.round(taskEstimation / storyEstimation * 100) : 0;
+      const estimationPercent = shares[index] ?? 0;
       return {
         id: this.generateTaskId(task.title, index),
         title: this.extractTitlePattern(task.title, story.title),
@@ -101716,16 +102679,12 @@ class LearnedTemplateProductBuilder {
         tags: story.tags?.length ? { include: story.tags } : undefined
       },
       tasks: taskDefinitions,
-      estimation: {
-        strategy: "percentage",
-        rounding: "none",
-        minimumTaskPoints: 0,
-        defaultParentEstimation: storyEstimation
-      }
+      estimation: learnedEstimationConfig([estimationSample(story, tasks)], estimationSource)
     };
   }
   generateSuggestions(analyses, patterns, confidence, outliers) {
     return [
+      ...this.suggestEstimationChecks(analyses),
       ...this.suggestConfidenceImprovements(analyses, confidence),
       ...this.suggestOutlierRemovals(outliers),
       ...this.suggestNamingImprovements(patterns),
@@ -101734,7 +102693,18 @@ class LearnedTemplateProductBuilder {
       ...this.suggestFilterImprovements(patterns)
     ];
   }
-  generateVariations(analyses, patterns, mergedTasks) {
+  suggestEstimationChecks(analyses) {
+    const learned = inferEstimation(analyses.map((a3) => estimationSample(a3.story, a3.tasks)));
+    const table = learned.conversion?.table;
+    if (!table)
+      return [];
+    return learned.lowConfidenceValues.map((value) => ({
+      type: "adjust-estimation",
+      message: `The conversion for "${value}" (${table[value]}) was learned from a single Story; check it before relying on it.`,
+      severity: "info"
+    }));
+  }
+  generateVariations(analyses, patterns, mergedTasks, estimationSource) {
     const confidenceScorer = new ConfidenceScorer;
     const variations = [];
     const coreTasks = mergedTasks.filter((mt) => {
@@ -101742,7 +102712,7 @@ class LearnedTemplateProductBuilder {
       return storyCount / analyses.length >= 0.6;
     });
     if (coreTasks.length > 0 && coreTasks.length !== mergedTasks.length) {
-      const coreTemplate = this.buildMergedTemplate(analyses, coreTasks);
+      const coreTemplate = this.buildMergedTemplate(analyses, coreTasks, estimationSource);
       coreTemplate.name = "Core Tasks Template";
       coreTemplate.description = "Tasks appearing in 60%+ of analyzed stories";
       variations.push({
@@ -101753,7 +102723,7 @@ class LearnedTemplateProductBuilder {
       });
     }
     if (mergedTasks.length > 0) {
-      const fullTemplate = this.buildMergedTemplate(analyses, mergedTasks);
+      const fullTemplate = this.buildMergedTemplate(analyses, mergedTasks, estimationSource);
       fullTemplate.name = "Comprehensive Template";
       fullTemplate.description = "All tasks found across analyzed stories";
       variations.push({
@@ -101876,6 +102846,23 @@ class LearnedTemplateProductBuilder {
     return suggestions;
   }
 }
+function estimationSample(story, tasks) {
+  return {
+    storyEstimate: story.estimation,
+    taskEstimates: tasks.map((task) => numericStoryEstimate(task.estimation))
+  };
+}
+function learnedEstimationConfig(samples, source) {
+  const learned = inferEstimation(samples);
+  return {
+    strategy: "percentage",
+    rounding: "none",
+    minimumTaskEstimate: 0,
+    ...source ? { source } : {},
+    ...learned.conversion ? { conversion: learned.conversion } : {},
+    ...learned.defaultStoryEstimate !== undefined ? { defaultParentEstimation: learned.defaultStoryEstimate } : {}
+  };
+}
 
 // ../atomize-core/src/services/template/task-merger.ts
 class TaskMerger {
@@ -101969,15 +102956,15 @@ class TaskMerger {
     for (const value of values) {
       counts.set(value, (counts.get(value) ?? 0) + 1);
     }
-    let mostCommon = values[0] ?? 0;
+    let mostCommon2 = values[0] ?? 0;
     let maxCount = 0;
     for (const [value, count] of counts) {
-      if (count > maxCount || count === maxCount && value > mostCommon) {
-        mostCommon = value;
+      if (count > maxCount || count === maxCount && value > mostCommon2) {
+        mostCommon2 = value;
         maxCount = count;
       }
     }
-    return mostCommon;
+    return mostCommon2;
   }
   averagePriority(values) {
     if (values.length === 0)
@@ -102082,27 +103069,28 @@ class StoryLearner {
     this.learningSession = learningSession;
     this.productBuilder = productBuilder;
   }
-  async learnFromStory(storyId) {
+  async learnFromStory(storyId, options = {}) {
     logger.info(`Learning template from story: ${storyId}`);
-    const story = await this.platform.getWorkItem(storyId);
-    if (!story) {
+    const fetched = await this.platform.getWorkItem(storyId);
+    if (!fetched) {
       throw new TemplateGenerationError(`Story ${storyId} not found`);
     }
+    const story = withEstimationSource(fetched, options.estimationSource);
     const tasks = await this.platform.getChildren(storyId);
     if (!tasks || tasks.length === 0) {
       throw new TemplateGenerationError(`Story ${storyId} has no child tasks to learn from`);
     }
     logger.info(`Found ${tasks.length} tasks to analyze`);
-    const template = this.productBuilder.buildSingleStoryTemplate(story, tasks);
+    const template = this.productBuilder.buildSingleStoryTemplate(story, tasks, options.estimationSource);
     logger.info("Template learned successfully");
     return template;
   }
-  async learnFromStories(storyIds) {
+  async learnFromStories(storyIds, options = {}) {
     logger.info(`Learning template from ${storyIds.length} stories: ${storyIds.join(", ")}`);
     if (storyIds.length === 0) {
       throw new TemplateGenerationError("No story IDs provided");
     }
-    const results = await Promise.allSettled(storyIds.map((id) => this.analyzeStory(id)));
+    const results = await Promise.allSettled(storyIds.map((id) => this.analyzeStory(id, options.estimationSource)));
     const analyses = [];
     const skipped = [];
     for (let i3 = 0;i3 < results.length; i3++) {
@@ -102134,9 +103122,9 @@ class StoryLearner {
       confidence,
       outliers
     } = this.learningSession.run(analyses);
-    const template = this.productBuilder.buildMergedTemplate(analyses, mergedTasks);
+    const template = this.productBuilder.buildMergedTemplate(analyses, mergedTasks, options.estimationSource);
     const suggestions = this.productBuilder.generateSuggestions(analyses, patterns, confidence, outliers);
-    const variations = this.productBuilder.generateVariations(analyses, patterns, mergedTasks);
+    const variations = this.productBuilder.generateVariations(analyses, patterns, mergedTasks, options.estimationSource);
     logger.info(`Multi-story learning complete: ${analyses.length} analyzed, ${skipped.length} skipped, confidence: ${confidence.level} (${confidence.overall}%)`);
     return {
       analyses,
@@ -102149,11 +103137,12 @@ class StoryLearner {
       outliers
     };
   }
-  async analyzeStory(storyId) {
-    const story = await this.platform.getWorkItem(storyId);
-    if (!story) {
+  async analyzeStory(storyId, estimationSource) {
+    const fetched = await this.platform.getWorkItem(storyId);
+    if (!fetched) {
       throw new TemplateGenerationError(`Story ${storyId} not found`);
     }
+    const story = withEstimationSource(fetched, estimationSource);
     const tasks = await this.platform.getChildren(storyId);
     const warnings = [];
     if (tasks.length === 0) {
@@ -102168,7 +103157,7 @@ class StoryLearner {
     if (tasks.length === 1) {
       warnings.push(`Story ${storyId} has only 1 task, which may not be representative`);
     }
-    const template = this.productBuilder.buildSingleStoryTemplate(story, tasks);
+    const template = this.productBuilder.buildSingleStoryTemplate(story, tasks, estimationSource);
     return { story, tasks, template, warnings };
   }
   extractTitlePattern(taskTitle, storyTitle) {
@@ -102181,6 +103170,11 @@ class StoryLearner {
     return this.productBuilder.detectActivity(title, description);
   }
 }
+function withEstimationSource(story, source) {
+  if (!source)
+    return story;
+  return { ...story, estimation: readStoryEstimate(story, { kind: "override", field: source }) };
+}
 
 // src/cli/commands/template/template-create.command.ts
 init_template_library();
@@ -102576,6 +103570,8 @@ mixins: string[]        # optional — list of mixin references or file paths (e
                         # Mixins contribute tasks only. Child tasks override mixin tasks with the same id.
                         # Template names are NOT valid mixin sources.
 
+taskType: string        # optional — work item type Tasks are created as (e.g. "Task", "Sub-task"). Omit to use the platform default.
+
 filter:                 # required (unless inherited via extends)
   workItemTypes: string[]         # e.g. ["User Story"], ["Bug"]
   states: string[]                # e.g. ["New", "Active", "Approved"] — items must be in one of these states
@@ -102606,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"):
@@ -102627,11 +103624,21 @@ tasks:                  # required, minimum 1 item
 estimation:             # optional
   strategy: "percentage"
   rounding: "nearest" | "up" | "down" | "none"   # default "none" — omit unless the user asks for rounding
-  minimumTaskPoints: number   # optional, default 0
+  normalize: "auto" | "always" | "never"          # optional, default "auto" — set "never" only if the user wants percentages used exactly as written
+  minimumTaskEstimate: number   # optional, default 0 — minimum per task, in the Task's unit (hours on Azure DevOps)
+  source: string                # optional — Story field reference name holding the Story Estimate (e.g. "Custom.TShirtSize"). Omit to use the platform default (story points / effort / size).
+  conversion:                   # optional — Story Estimate → Task-unit total before the split. Set exactly ONE of factor or table.
+    factor: number              #   e.g. 4 when 1 point = 4 hours
+    table:                      #   exact value → amount, e.g. { S: 2, M: 4, L: 5, XL: 13 }
+    multipliers: boolean        #   optional, only with a table of size keys: "0.3XL" = 0.3 × XL
+  targetFields: string[]        # optional — Task fields that receive the estimate, replacing the platform defaults. Rarely needed.
+  ifParentHasNoEstimation: "warn" | "skip" | "use-default"   # optional, default "warn" (tasks get blank estimates)
+  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
@@ -102646,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.
@@ -102672,6 +103679,17 @@ CONSTRAINTS (you must follow these):
          estimationPercentCondition:
            - condition: { field: priority, operator: lte, value: 2 }
              percent: 35             # override for critical bugs (priority 1 or 2)
+8. ESTIMATION FIELDS: only set taskType, estimation.source, estimation.conversion or estimation.targetFields when the user describes non-default sizing (for example t-shirt sizes, a custom size field, or "1 point = 4 hours"), or when the workspace context lists an estimation field that matches the description.
+   - Use field reference names and work item types exactly as given in the workspace context; never invent them.
+   - 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:
 
@@ -102875,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;
 }
@@ -102890,7 +103933,7 @@ ${description}`;
 Observed patterns from this user's Azure DevOps workspace:
 ${groundingContext}
 
-Use these patterns as concrete examples when choosing task names, estimation percentages, and conditions. Adapt them to fit the description above — do not copy verbatim.
+Use these patterns as concrete examples when choosing task names, estimation percentages, and conditions. Adapt them to fit the description above — do not copy verbatim. If the context has an "estimation" section, it lists the platform's default estimation fields and the Story fields that can hold a Story Estimate, with their allowed values; follow rule 8 when using them.
 ---`;
   }
   if (prevErrors && prevErrors.length > 0) {
@@ -102944,6 +103987,7 @@ init_prompt_utilities();
 
 // src/cli/commands/template/template-wizard.ts
 init_dist6();
+init_schema2();
 init_errors();
 init_estimation_normalizer();
 init_source();
@@ -103189,7 +104233,7 @@ var STORY_FIELDS = [
   { label: "Tags (array)", value: "tags" },
   { label: "Title", value: "title" },
   { label: "State", value: "state" },
-  { label: "Estimation (points)", value: "estimation" },
+  { label: "Story Estimate (raw value, e.g. points or size)", value: "estimation" },
   { label: "Priority", value: "priority" },
   { label: "Description", value: "description" },
   { label: "Assigned To", value: "assignedTo" },
@@ -103438,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) {
@@ -103456,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)
@@ -103499,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) {
@@ -103527,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?",
@@ -103539,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
@@ -103579,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((sum, task) => sum + (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}`));
     }
@@ -103615,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)
@@ -103679,8 +104759,9 @@ Editing Tasks
 Editing Estimation Settings
 `));
     const { configureEstimation: configureEstimation2 } = await Promise.resolve().then(() => (init_template_wizard_helper_command(), exports_template_wizard_helper_command));
-    const estimation = await configureEstimation2(template.estimation);
+    const { estimation, taskType } = await configureEstimation2(template.estimation, ctx.estimationCtx ?? { storyFields: ctx.storyFieldSchemas, workItemTypes: ctx.filterCtx.workItemTypes }, template.taskType);
     template.estimation = estimation;
+    template.taskType = taskType;
   }).with("validation", async () => {
     output4.print(source_default.cyan(`
 Editing Validation Rules
@@ -103745,7 +104826,7 @@ function showStepHint(stepName) {
   const hints = {
     filter: "Tip: Use filters to select which work items this template applies to",
     tasks: "Tip: Break work into clear, actionable tasks. Estimation percentages will be normalized to 100%. If you plan on set dependencies, please set task IDs.",
-    estimation: "Tip: Choose how story points will be calculated and rounded",
+    estimation: "Tip: Choose how Story Estimates turn into Task hours and where they are written",
     validation: "Tip: Add constraints to ensure templates are used correctly",
     metadata: "Tip: Metadata helps others understand when to use this template"
   };
@@ -103815,13 +104896,17 @@ async function shouldAddMoreTasks(taskCounter) {
   }));
 }
 async function handleEstimationNormalization(tasks) {
-  const totalEstimation = tasks.reduce((sum, task) => sum + (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);
@@ -103859,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();
   };
@@ -103881,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
           }))
         }));
@@ -103898,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
           }))
         }));
@@ -103943,6 +105028,7 @@ Customize Template
     const adapter = await createAzureDevOpsAdapter(profile);
     const metadataReader = requireProjectMetadataReader(adapter);
     const savedQueryReader = requireSavedQueryReader(adapter);
+    const estimationDefaults2 = adapter.getEstimationDefaults();
     const [
       taskSchemas,
       liveWorkItemTypes,
@@ -103951,7 +105037,7 @@ Customize Template
       liveTeams,
       liveSavedQueries
     ] = await Promise.all([
-      metadataReader.getFieldSchemas("Task"),
+      metadataReader.getFieldSchemas(template.taskType ?? estimationDefaults2.taskWorkItemType),
       metadataReader.getWorkItemTypes(),
       metadataReader.getAreaPaths(),
       metadataReader.getIterationPaths(),
@@ -103960,6 +105046,7 @@ Customize Template
     ]);
     return {
       metadataReader,
+      estimationDefaults: estimationDefaults2,
       fieldSchemas: taskSchemas,
       filterCtx: {
         workItemTypes: liveWorkItemTypes,
@@ -104007,6 +105094,7 @@ Editing Name & Description
   let filterCtx;
   let fieldSchemas;
   let adapterForWizard;
+  let estimationDefaults;
   try {
     const conn = await connectionPromise;
     if (!wasAlreadyConnected)
@@ -104014,6 +105102,7 @@ Editing Name & Description
     filterCtx = conn.filterCtx;
     fieldSchemas = conn.fieldSchemas;
     adapterForWizard = conn.metadataReader;
+    estimationDefaults = conn.estimationDefaults;
   } catch (err) {
     if (!wasAlreadyConnected)
       connectSpinner.stop("Connection failed");
@@ -104025,6 +105114,12 @@ Editing Name & Description
   }
   let storyFieldSchemas = [];
   let storySchemasFetched = false;
+  const estimationContext = async () => ({
+    storyFields: storyFieldSchemas.length ? storyFieldSchemas : await adapterForWizard.getFieldSchemas(),
+    workItemTypes: filterCtx.workItemTypes,
+    defaults: estimationDefaults,
+    getTaskFields: (type) => adapterForWizard.getFieldSchemas(type)
+  });
   for (const section of ["filter", "tasks", "estimation", "validation", "metadata"]) {
     if (!sections.includes(section))
       continue;
@@ -104062,7 +105157,14 @@ Editing Tasks
         output5.print(source_default.cyan(`
 Editing Estimation Settings
 `));
-        template.estimation = await configureEstimation(template.estimation);
+        if (!storySchemasFetched) {
+          const wit = template.filter.workItemTypes?.[0];
+          storyFieldSchemas = wit ? await adapterForWizard.getFieldSchemas(wit) : [];
+          storySchemasFetched = true;
+        }
+        const { estimation, taskType } = await configureEstimation(template.estimation, await estimationContext(), template.taskType);
+        template.estimation = estimation;
+        template.taskType = taskType;
         break;
       }
       case "validation": {
@@ -104103,7 +105205,8 @@ Editing Metadata
     filterCtx,
     fieldSchemas,
     storyFieldSchemas,
-    workItemType: template.filter.workItemTypes?.[0]
+    workItemType: template.filter.workItemTypes?.[0],
+    estimationCtx: await estimationContext()
   };
   const confirmed = await previewTemplate(template, wizardCtx);
   if (!confirmed) {
@@ -104421,7 +105524,7 @@ async function handlePreviewLoop(template, options) {
 // src/cli/commands/template/template-create.command.ts
 init_template_wizard_helper_command();
 var defaultOutput = createCommandOutput(resolveCommandOutputPolicy({}));
-var templateCreateCommand = new Command("create").description("Create a new template interactively").option("--type <type>", "Create as template or mixin").option("--from <name>", "Start from an existing template").option("--from-stories <ids>", "Learn template from multiple stories (comma-separated IDs)").option("-p, --platform <platform>", "Platform to use", "azure-devops").option("--profile <name>", "Connect to ADO using a named profile for field suggestions (uses default profile if omitted)").option("--scratch", "Create from scratch (skip mode selection)").option("--ai", "Use AI-assisted generation (describe the template in natural language)").option("--ground", "Ground AI generation with patterns from your Azure DevOps workspace").option("--save-as <name>", "Name to save the template under").option("--open", "Open the saved Atomize YAML file in a supported editor", false).option("-q, --quiet", "Suppress non-essential output", false).action(async (options) => {
+var templateCreateCommand = new Command("create").description("Create a new template interactively").option("--type <type>", "Create as template or mixin").option("--from <name>", "Start from an existing template").option("--from-stories <ids>", "Learn template from multiple stories (comma-separated IDs)").option("--estimation-source <field>", "With --from-stories, read each Story Estimate from this field reference name (e.g. Custom.TShirtSize) and write it as estimation.source").option("-p, --platform <platform>", "Platform to use", "azure-devops").option("--profile <name>", "Connect to ADO using a named profile for field suggestions (uses default profile if omitted)").option("--scratch", "Create from scratch (skip mode selection)").option("--ai", "Use AI-assisted generation (describe the template in natural language)").option("--ground", "Ground AI generation with patterns from your Azure DevOps workspace").option("--save-as <name>", "Name to save the template under").option("--open", "Open the saved Atomize YAML file in a supported editor", false).option("-q, --quiet", "Suppress non-essential output", false).action(async (options) => {
   const output9 = createCommandOutput(resolveCommandOutputPolicy({ quiet: options.quiet, verbose: false }));
   try {
     output9.intro(" Atomize — Template Creator");
@@ -104680,7 +105783,7 @@ async function createFromStories(options) {
   const learner = new StoryLearner(learningPlatform);
   const learnSpinner = createManagedSpinner();
   learnSpinner.start(`Learning from ${storyIds.length} stories...`);
-  const result = await learner.learnFromStories(storyIds);
+  const result = await learner.learnFromStories(storyIds, { estimationSource: options.estimationSource });
   learnSpinner.stop(`Analyzed ${result.analyses.length} stories ✓`);
   displayMultiStoryResults(result);
   if (result.variations.length > 1) {
@@ -104776,8 +105879,9 @@ Create Template from Scratch
       const adapter = await createAzureDevOpsAdapter(profile);
       const metadataReader = requireProjectMetadataReader(adapter);
       const savedQueryReader = requireSavedQueryReader(adapter);
+      const estimationDefaults2 = adapter.getEstimationDefaults();
       const [taskSchemas, liveWorkItemTypes, liveAreaPaths, liveIterationPaths, liveTeams, liveSavedQueries] = await Promise.all([
-        metadataReader.getFieldSchemas("Task"),
+        metadataReader.getFieldSchemas(estimationDefaults2.taskWorkItemType),
         metadataReader.getWorkItemTypes(),
         metadataReader.getAreaPaths(),
         metadataReader.getIterationPaths(),
@@ -104786,6 +105890,7 @@ Create Template from Scratch
       ]);
       return {
         metadataReader,
+        estimationDefaults: estimationDefaults2,
         fieldSchemas: taskSchemas,
         filterCtx: {
           workItemTypes: liveWorkItemTypes,
@@ -104812,6 +105917,7 @@ Create Template from Scratch
     let filterCtx;
     let fieldSchemas;
     let adapterForWizard;
+    let estimationDefaults;
     const wasAlreadyConnected = connectionSettled;
     const connectSpinner = createManagedSpinner();
     if (!wasAlreadyConnected)
@@ -104823,6 +105929,7 @@ Create Template from Scratch
       filterCtx = conn.filterCtx;
       fieldSchemas = conn.fieldSchemas;
       adapterForWizard = conn.metadataReader;
+      estimationDefaults = conn.estimationDefaults;
     } catch (err) {
       if (!wasAlreadyConnected)
         connectSpinner.stop("Connection failed");
@@ -104870,9 +105977,15 @@ Create Template from Scratch
     printStep(source_default.blue(`
 [${currentStep}/${totalSteps}] Estimation Settings`));
     printStep(source_default.gray("████░░"));
-    printStep(source_default.gray(`Tip: Choose how story points will be calculated and rounded
+    printStep(source_default.gray(`Tip: Choose how Story Estimates turn into Task hours and where they are written
 `));
-    const estimation = await configureEstimation();
+    const estimationCtx = {
+      storyFields: storyFieldSchemas.length ? storyFieldSchemas : await adapterForWizard.getFieldSchemas(),
+      workItemTypes: filterCtx.workItemTypes,
+      defaults: estimationDefaults,
+      getTaskFields: (type) => adapterForWizard.getFieldSchemas(type)
+    };
+    const { estimation, taskType } = await configureEstimation(undefined, estimationCtx);
     currentStep++;
     printStep(source_default.blue(`
 [${currentStep}/${totalSteps}] Validation Rules (Optional)`));
@@ -104912,6 +106025,7 @@ Create Template from Scratch
       created: new Date().toISOString(),
       filter: filterConfig,
       tasks,
+      ...taskType ? { taskType } : {},
       estimation,
       validation,
       metadata
@@ -104925,7 +106039,8 @@ Create Template from Scratch
       filterCtx,
       fieldSchemas,
       storyFieldSchemas,
-      workItemType
+      workItemType,
+      estimationCtx
     };
     const confirmed = await previewTemplate(template, wizardCtx);
     if (!confirmed) {
@@ -105568,6 +106683,7 @@ init_dist6();
 init_logger2();
 init_estimation_distribution();
 init_custom_field_verifier();
+init_schema2();
 init_template_library();
 init_errors();
 init_source();
@@ -105711,7 +106827,9 @@ function createValidateCommandDeps(depsOptions) {
             strict: options.strict === true,
             platform: {
               getFieldSchemas: (workItemType) => metadataReader.getFieldSchemas(workItemType),
-              listSavedQueries: (folder) => savedQueryReader.listSavedQueries(folder)
+              listSavedQueries: (folder) => savedQueryReader.listSavedQueries(folder),
+              getEstimationDefaults: () => adapter.getEstimationDefaults(),
+              getWorkItemTypes: adapter.getWorkItemTypes?.bind(adapter)
             }
           },
           connectionWarnings: []
@@ -105800,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}%`
   };
 }