@sppg2001/atomize 4.0.1 → 4.1.0

package/dist/cli/index.js

@@ -178,6 +178,30 @@ var init_errors = __esm(() => {
   };
 });
 
+// ../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,6 +20089,25 @@ 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)];
@@ -20162,7 +20205,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, 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 +20262,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(),
@@ -20276,14 +20319,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(),
@@ -20326,6 +20397,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(),
@@ -20933,6 +21005,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 +21066,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 +21159,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 +21243,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;
@@ -21130,11 +21300,19 @@ 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 = [];
@@ -21143,7 +21321,7 @@ class EstimationCalculator {
       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 +21336,47 @@ class EstimationCalculator {
         }
         logger.debug(`Task "${templateTask.title}" - condition met: ${JSON.stringify(templateTask.condition)}`);
       }
-      const resolvedPercent = this.resolveEffectivePercent(templateTask, story);
+      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;
+      }
       const calculatedTask = this.buildCalculatedTask(templateTask, story, connectUserEmail, 0, resolvedPercent);
       calculatedTasks.push(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 +21393,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 +21401,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 +21412,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 +21455,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 +21468,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 +21492,7 @@ var init_estimation_calculator = __esm(() => {
   init_logger();
   init_errors();
   init_condition_evaluator();
+  init_estimation_conversion();
   init_estimation_distribution();
 });
 
@@ -21361,27 +21569,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 +21632,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 +80111,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 +80164,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 +80222,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 +80236,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 +80323,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 +80357,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 +80381,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 +80647,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 +80755,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 +80798,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 +81013,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 +81267,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 +81335,9 @@ class MockPlatformAdapter {
     logger.info(`MockPlatform: Deleted work item ${id}`);
     return true;
   }
+  getEstimationDefaults() {
+    return MOCK_ESTIMATION_DEFAULTS;
+  }
   getPlatformMetadata() {
     return {
       name: "Mock Platform",
@@ -81109,9 +81384,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 +89046,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
@@ -89197,10 +89480,11 @@ class TemplateValidator {
     const v2 = template.validation;
     const total = template.tasks.reduce((sum, t2) => sum + (t2.estimationPercent ?? 0), 0);
     const hasStrictRule = v2?.totalEstimationMustBe !== undefined || v2?.totalEstimationRange !== undefined;
-    if (!hasStrictRule && total > 100) {
+    const 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 +89499,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 +89573,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."
       });
     }
   }
@@ -89417,15 +89724,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 +89747,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 +89899,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 +90075,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 +90152,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 +93277,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 +93384,25 @@ var init_prompt_utilities = __esm(() => {
         return required2;
       return Validators.maxLength(fieldName, maxLength)(input2);
     },
+    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 +93716,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 +93793,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 +93878,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 +93893,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 +93915,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 +94211,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 +94227,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 +94732,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 +98679,7 @@ var program = new Command;
 
 // package.json
 var name = "@sppg2001/atomize";
-var version2 = "4.0.1";
+var version2 = "4.1.0";
 
 // src/cli/commands/auth/auth-add.command.ts
 init_dist6();
@@ -99396,16 +100181,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 ? `${value} ${result.estimateUnit}` : String(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 +100372,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 +100391,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 +100450,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 +100497,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 +100525,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 +100848,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 +101502,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 +101537,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 +101650,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 +101821,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 +101913,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 +101936,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 +102086,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 +102168,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 +102248,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 +102289,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 +102311,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 +102322,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 +102376,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 +102428,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 +102497,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 +102518,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 +102531,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 +102552,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 +102579,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 +102593,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 +102612,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 +102623,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 +102746,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 +102856,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 +102969,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 +103022,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 +103037,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 +103057,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 +103070,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 +103470,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
@@ -102627,7 +103523,16 @@ 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
@@ -102672,6 +103577,11 @@ 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.
 
 EXAMPLES:
 
@@ -102890,7 +103800,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) {
@@ -103189,7 +104099,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" },
@@ -103581,7 +104491,7 @@ Filter Configuration:`));
 function displayTasksSummary(template) {
   output4.print(source_default.bold(`
 Tasks (${template.tasks.length}):`));
-  const totalEstimation = template.tasks.reduce((sum, task) => sum + (task.estimationPercent || 0), 0);
+  const totalEstimation = template.tasks.reduce((sum2, task) => sum2 + (task.estimationPercent || 0), 0);
   template.tasks.forEach((task, index) => {
     const percent = task.estimationPercent || 0;
     const bar = "■".repeat(Math.round(percent / 5));
@@ -103679,8 +104589,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 +104656,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,7 +104726,7 @@ async function shouldAddMoreTasks(taskCounter) {
   }));
 }
 async function handleEstimationNormalization(tasks) {
-  const totalEstimation = tasks.reduce((sum, task) => sum + (task.estimationPercent || 0), 0);
+  const totalEstimation = tasks.reduce((sum2, task) => sum2 + (task.estimationPercent || 0), 0);
   if (totalEstimation === 100) {
     output4.print(source_default.green("✓ Total estimation is 100%"));
     return;
@@ -103943,6 +104854,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 +104863,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 +104872,7 @@ Customize Template
     ]);
     return {
       metadataReader,
+      estimationDefaults: estimationDefaults2,
       fieldSchemas: taskSchemas,
       filterCtx: {
         workItemTypes: liveWorkItemTypes,
@@ -104007,6 +104920,7 @@ Editing Name & Description
   let filterCtx;
   let fieldSchemas;
   let adapterForWizard;
+  let estimationDefaults;
   try {
     const conn = await connectionPromise;
     if (!wasAlreadyConnected)
@@ -104014,6 +104928,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 +104940,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 +104983,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 +105031,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 +105350,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 +105609,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 +105705,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 +105716,7 @@ Create Template from Scratch
       ]);
       return {
         metadataReader,
+        estimationDefaults: estimationDefaults2,
         fieldSchemas: taskSchemas,
         filterCtx: {
           workItemTypes: liveWorkItemTypes,
@@ -104812,6 +105743,7 @@ Create Template from Scratch
     let filterCtx;
     let fieldSchemas;
     let adapterForWizard;
+    let estimationDefaults;
     const wasAlreadyConnected = connectionSettled;
     const connectSpinner = createManagedSpinner();
     if (!wasAlreadyConnected)
@@ -104823,6 +105755,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 +105803,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 +105851,7 @@ Create Template from Scratch
       created: new Date().toISOString(),
       filter: filterConfig,
       tasks,
+      ...taskType ? { taskType } : {},
       estimation,
       validation,
       metadata
@@ -104925,7 +105865,8 @@ Create Template from Scratch
       filterCtx,
       fieldSchemas,
       storyFieldSchemas,
-      workItemType
+      workItemType,
+      estimationCtx
     };
     const confirmed = await previewTemplate(template, wizardCtx);
     if (!confirmed) {
@@ -105711,7 +106652,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: []