@unbrained/pm-cli 2026.6.30 → 2026.7.2

package/dist/cli-bundle/chunks/{chunk-V3KLX7U7.js → chunk-KN3URLKS.js}

@@ -1,14 +1,15 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="da8f95fe-2b22-59c6-af82-e0bd090502e4")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="89ae7463-1314-574c-9158-0967e6d9c589")}catch(e){}}();
 import {
   compareTimestampStrings,
   isTimestampLiteral
-} from "./chunk-KRASIL6M.js";
+} from "./chunk-K2VYLVX4.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   EXIT_CODE,
   FRONT_MATTER_KEY_ORDER,
   ISSUE_SEVERITY_VALUES,
+  PLAN_STEP_STATUS_VALUES,
   PmCliError,
   RECURRENCE_FREQUENCY_VALUES,
   RECURRENCE_WEEKDAY_VALUES,
@@ -19,7 +20,7 @@ import {
   resolveRuntimeStatusRegistry,
   runtimeFieldOptionTarget,
   weekdayOrderIndex
-} from "./chunk-CY5IJMUM.js";
+} from "./chunk-I66WE2HE.js";
 
 // dist/core/schema/runtime-field-values.js
 function toCamelToken(value) {
@@ -304,6 +305,8 @@ function decodeToonItemContent(content) {
 
 // dist/core/item/item-format.js
 var LINKED_TEST_PM_CONTEXT_MODE_VALUES = /* @__PURE__ */ new Set(["schema", "tracker", "auto"]);
+var ITEM_TEST_RUN_STATUS_VALUES = /* @__PURE__ */ new Set(["passed", "failed", "stopped", "canceled"]);
+var PLAN_STEP_STATUS_SET = new Set(PLAN_STEP_STATUS_VALUES);
 function normalizePathValue(value) {
   return value.replaceAll("\\", "/");
 }
@@ -315,6 +318,13 @@ function firstNonZeroComparison(comparisons) {
   }
   return 0;
 }
+function deleteUndefinedFields(record) {
+  for (const [key, value] of Object.entries(record)) {
+    if (value === void 0) {
+      delete record[key];
+    }
+  }
+}
 var REQUIRED_STRING_FIELDS = [
   "id",
   "title",
@@ -368,47 +378,65 @@ function assertTimestampField(record, fieldName) {
   const timestamp = rawValue;
   assertFrontMatterCondition(isTimestampLiteral(timestamp), `${fieldName} must be a valid ISO timestamp`);
 }
+function assertPositiveIntegerField(record, fieldName, messagePrefix) {
+  const value = record[fieldName];
+  if (value === void 0) {
+    return;
+  }
+  assertFrontMatterCondition(typeof value === "number" && Number.isInteger(value) && value >= 1, `${messagePrefix} must be an integer >= 1`);
+}
+function assertOptionalTimestampString(record, fieldName, messagePrefix) {
+  const value = record[fieldName];
+  if (value === void 0) {
+    return;
+  }
+  assertFrontMatterCondition(typeof value === "string", `${messagePrefix} must be a string`);
+  assertFrontMatterCondition(isTimestampLiteral(value), `${messagePrefix} must be a valid ISO timestamp`);
+}
+function assertRecurrenceWeekdays(value) {
+  if (value === void 0) {
+    return;
+  }
+  assertFrontMatterCondition(Array.isArray(value), "event.recurrence.by_weekday must be an array");
+  for (const weekday of value) {
+    assertFrontMatterCondition(typeof weekday === "string", "event.recurrence.by_weekday entries must be strings");
+    const normalizedWeekday = weekday.trim().toLowerCase();
+    assertFrontMatterCondition(RECURRENCE_WEEKDAY_VALUES.includes(normalizedWeekday), `event.recurrence.by_weekday entries must be one of: ${RECURRENCE_WEEKDAY_VALUES.join(", ")}`);
+  }
+}
+function assertRecurrenceMonthDays(value) {
+  if (value === void 0) {
+    return;
+  }
+  assertFrontMatterCondition(Array.isArray(value), "event.recurrence.by_month_day must be an array");
+  for (const day of value) {
+    assertFrontMatterCondition(typeof day === "number" && Number.isInteger(day) && day >= 1 && day <= 31, "event.recurrence.by_month_day entries must be integers 1..31");
+  }
+}
+function assertRecurrenceExdates(value) {
+  if (value === void 0) {
+    return;
+  }
+  assertFrontMatterCondition(Array.isArray(value), "event.recurrence.exdates must be an array");
+  for (const exdate of value) {
+    assertFrontMatterCondition(typeof exdate === "string", "event.recurrence.exdates entries must be strings");
+    assertFrontMatterCondition(isTimestampLiteral(exdate), "event.recurrence.exdates entries must be valid ISO timestamps");
+  }
+}
 function assertValidRecurrenceRule(recurrence) {
   assertFrontMatterCondition(typeof recurrence === "object" && recurrence !== null && !Array.isArray(recurrence), "event.recurrence must be an object");
   const recurrenceRecord = recurrence;
   assertFrontMatterCondition(typeof recurrenceRecord.freq === "string", "event.recurrence.freq must be a string");
   const frequency = recurrenceRecord.freq.trim().toLowerCase();
   assertFrontMatterCondition(RECURRENCE_FREQUENCY_VALUES.includes(frequency), `event.recurrence.freq must be one of: ${RECURRENCE_FREQUENCY_VALUES.join(", ")}`);
-  if (recurrenceRecord.interval !== void 0) {
-    assertFrontMatterCondition(typeof recurrenceRecord.interval === "number" && Number.isInteger(recurrenceRecord.interval) && recurrenceRecord.interval >= 1, "event.recurrence.interval must be an integer >= 1");
-  }
-  if (recurrenceRecord.count !== void 0) {
-    assertFrontMatterCondition(typeof recurrenceRecord.count === "number" && Number.isInteger(recurrenceRecord.count) && recurrenceRecord.count >= 1, "event.recurrence.count must be an integer >= 1");
-  }
-  if (recurrenceRecord.until !== void 0) {
-    assertFrontMatterCondition(typeof recurrenceRecord.until === "string", "event.recurrence.until must be a string");
-    assertFrontMatterCondition(isTimestampLiteral(recurrenceRecord.until), "event.recurrence.until must be a valid ISO timestamp");
-  }
-  if (recurrenceRecord.by_weekday !== void 0) {
-    assertFrontMatterCondition(Array.isArray(recurrenceRecord.by_weekday), "event.recurrence.by_weekday must be an array");
-    for (const weekday of recurrenceRecord.by_weekday) {
-      assertFrontMatterCondition(typeof weekday === "string", "event.recurrence.by_weekday entries must be strings");
-      const normalizedWeekday = weekday.trim().toLowerCase();
-      assertFrontMatterCondition(RECURRENCE_WEEKDAY_VALUES.includes(normalizedWeekday), `event.recurrence.by_weekday entries must be one of: ${RECURRENCE_WEEKDAY_VALUES.join(", ")}`);
-    }
-  }
-  if (recurrenceRecord.by_month_day !== void 0) {
-    assertFrontMatterCondition(Array.isArray(recurrenceRecord.by_month_day), "event.recurrence.by_month_day must be an array");
-    for (const day of recurrenceRecord.by_month_day) {
-      assertFrontMatterCondition(typeof day === "number" && Number.isInteger(day) && day >= 1 && day <= 31, "event.recurrence.by_month_day entries must be integers 1..31");
-    }
-  }
-  if (recurrenceRecord.exdates !== void 0) {
-    assertFrontMatterCondition(Array.isArray(recurrenceRecord.exdates), "event.recurrence.exdates must be an array");
-    for (const exdate of recurrenceRecord.exdates) {
-      assertFrontMatterCondition(typeof exdate === "string", "event.recurrence.exdates entries must be strings");
-      assertFrontMatterCondition(isTimestampLiteral(exdate), "event.recurrence.exdates entries must be valid ISO timestamps");
-    }
-  }
-}
-function assertValidFrontMatter(frontMatter, runtimeContext) {
-  assertFrontMatterCondition(typeof frontMatter === "object" && frontMatter !== null && !Array.isArray(frontMatter), "front matter must be an object");
-  const record = frontMatter;
+  assertPositiveIntegerField(recurrenceRecord, "interval", "event.recurrence.interval");
+  assertPositiveIntegerField(recurrenceRecord, "count", "event.recurrence.count");
+  assertOptionalTimestampString(recurrenceRecord, "until", "event.recurrence.until");
+  assertRecurrenceWeekdays(recurrenceRecord.by_weekday);
+  assertRecurrenceMonthDays(recurrenceRecord.by_month_day);
+  assertRecurrenceExdates(recurrenceRecord.exdates);
+}
+function assertRequiredFrontMatterFields(record) {
   for (const fieldName of REQUIRED_STRING_FIELDS) {
     assertFrontMatterCondition(typeof record[fieldName] === "string", `${fieldName} is required and must be a string`);
   }
@@ -418,12 +446,17 @@ function assertValidFrontMatter(frontMatter, runtimeContext) {
   if (formatVersion !== void 0) {
     assertFrontMatterCondition(typeof formatVersion === "number" && Number.isInteger(formatVersion) && formatVersion >= BASELINE_ITEM_FORMAT_VERSION, `pm_format_version must be an integer >= ${BASELINE_ITEM_FORMAT_VERSION}`);
   }
+  return itemType;
+}
+function assertStatusFrontMatterField(record, runtimeContext) {
   const status = record.status;
   assertFrontMatterCondition(typeof status === "string" && status.trim().length > 0, "status must be a non-empty string");
   const statusRegistry = runtimeContext?.statusRegistry;
   const normalizedStatus = normalizeStatusInput(status, statusRegistry);
   const statusDomain = statusRegistry ? statusRegistry.definitions.map((definition) => definition.id) : [...STATUS_VALUES];
   assertFrontMatterCondition(normalizedStatus !== void 0, `status must be one of: ${statusDomain.join(", ")}`);
+}
+function assertPriorityAndTags(record) {
   const priority = record.priority;
   assertFrontMatterCondition(typeof priority === "number" && Number.isInteger(priority) && [0, 1, 2, 3, 4].includes(priority), "priority must be an integer 0..4");
   const tags = record.tags;
@@ -431,129 +464,176 @@ function assertValidFrontMatter(frontMatter, runtimeContext) {
   for (const tag of tags) {
     assertFrontMatterCondition(typeof tag === "string", "tags entries must be strings");
   }
+}
+function assertConfidenceFrontMatterField(record) {
   const confidence = record.confidence;
-  if (confidence !== void 0) {
-    if (typeof confidence === "number") {
-      assertFrontMatterCondition(Number.isInteger(confidence) && confidence >= 0 && confidence <= 100, "confidence number value must be an integer 0..100");
-    } else if (typeof confidence === "string") {
-      const normalizedConfidence = confidence.trim().toLowerCase();
-      const isKnownTextConfidence = normalizedConfidence === "med" || CONFIDENCE_TEXT_VALUES.includes(normalizedConfidence);
-      assertFrontMatterCondition(isKnownTextConfidence, `confidence string value must be one of: ${[...CONFIDENCE_TEXT_VALUES, "med"].join(", ")}`);
-    } else {
-      assertFrontMatterCondition(false, "confidence must be a number or string");
-    }
+  if (confidence === void 0) {
+    return;
+  }
+  if (typeof confidence === "number") {
+    assertFrontMatterCondition(Number.isInteger(confidence) && confidence >= 0 && confidence <= 100, "confidence number value must be an integer 0..100");
+    return;
   }
+  if (typeof confidence === "string") {
+    const normalizedConfidence = confidence.trim().toLowerCase();
+    const isKnownTextConfidence = normalizedConfidence === "med" || CONFIDENCE_TEXT_VALUES.includes(normalizedConfidence);
+    assertFrontMatterCondition(isKnownTextConfidence, `confidence string value must be one of: ${[...CONFIDENCE_TEXT_VALUES, "med"].join(", ")}`);
+    return;
+  }
+  assertFrontMatterCondition(false, "confidence must be a number or string");
+}
+function assertSeverityFrontMatterField(record) {
   const severity = record.severity;
-  if (severity !== void 0) {
-    if (typeof severity !== "string") {
-      validationError("severity must be a string");
-    }
-    const normalizedSeverity = severity.trim().toLowerCase();
-    const isKnownSeverity = normalizedSeverity === "med" || ISSUE_SEVERITY_VALUES.includes(normalizedSeverity);
-    assertFrontMatterCondition(isKnownSeverity, `severity value must be one of: ${[...ISSUE_SEVERITY_VALUES, "med"].join(", ")}`);
-  }
-  const regression = record.regression;
-  if (regression !== void 0) {
-    if (typeof regression !== "boolean") {
-      validationError("regression must be a boolean");
-    }
+  if (severity === void 0) {
+    return;
   }
-  assertTimestampField(record, "created_at");
-  assertTimestampField(record, "updated_at");
-  if (record.deadline !== void 0) {
-    assertTimestampField(record, "deadline");
+  if (typeof severity !== "string") {
+    validationError("severity must be a string");
   }
-  if (record.reminders !== void 0) {
-    const reminders = record.reminders;
-    assertFrontMatterCondition(Array.isArray(reminders), "reminders must be an array");
-    for (const reminder of reminders) {
-      assertFrontMatterCondition(typeof reminder === "object" && reminder !== null && !Array.isArray(reminder), "reminders entries must be objects");
-      const reminderRecord = reminder;
-      assertFrontMatterCondition(typeof reminderRecord.at === "string", "reminder.at must be a string");
-      assertFrontMatterCondition(isTimestampLiteral(reminderRecord.at), "reminder.at must be a valid ISO timestamp");
-      assertFrontMatterCondition(typeof reminderRecord.text === "string", "reminder.text must be a string");
-      assertFrontMatterCondition(reminderRecord.text.trim().length > 0, "reminder.text must not be empty");
-    }
+  const normalizedSeverity = severity.trim().toLowerCase();
+  const isKnownSeverity = normalizedSeverity === "med" || ISSUE_SEVERITY_VALUES.includes(normalizedSeverity);
+  assertFrontMatterCondition(isKnownSeverity, `severity value must be one of: ${[...ISSUE_SEVERITY_VALUES, "med"].join(", ")}`);
+}
+function assertRegressionFrontMatterField(record) {
+  if (record.regression !== void 0 && typeof record.regression !== "boolean") {
+    validationError("regression must be a boolean");
   }
-  if (record.events !== void 0) {
-    const events = record.events;
-    assertFrontMatterCondition(Array.isArray(events), "events must be an array");
-    for (const event of events) {
-      assertFrontMatterCondition(typeof event === "object" && event !== null && !Array.isArray(event), "events entries must be objects");
-      const eventRecord = event;
-      assertFrontMatterCondition(typeof eventRecord.start_at === "string", "event.start_at must be a string");
-      assertFrontMatterCondition(isTimestampLiteral(eventRecord.start_at), "event.start_at must be a valid ISO timestamp");
-      if (eventRecord.end_at !== void 0) {
-        assertFrontMatterCondition(typeof eventRecord.end_at === "string", "event.end_at must be a string");
-        assertFrontMatterCondition(isTimestampLiteral(eventRecord.end_at), "event.end_at must be a valid ISO timestamp");
-        assertFrontMatterCondition(compareTimestampStrings(eventRecord.end_at, eventRecord.start_at) > 0, "event.end_at must be after event.start_at");
-      }
-      for (const stringField of ["title", "description", "location", "timezone"]) {
-        if (eventRecord[stringField] !== void 0) {
-          assertFrontMatterCondition(typeof eventRecord[stringField] === "string", `event.${stringField} must be a string`);
-          assertFrontMatterCondition(eventRecord[stringField].trim().length > 0, `event.${stringField} must not be empty`);
-        }
-      }
-      if (eventRecord.all_day !== void 0) {
-        assertFrontMatterCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
-      }
-      if (eventRecord.recurrence !== void 0) {
-        assertValidRecurrenceRule(eventRecord.recurrence);
-        if (eventRecord.recurrence.until !== void 0) {
-          assertFrontMatterCondition(compareTimestampStrings(eventRecord.recurrence.until, eventRecord.start_at) >= 0, "event.recurrence.until must be at or after event.start_at");
-        }
-      }
+}
+function assertReminderEntries(record) {
+  const reminders = record.reminders;
+  if (reminders === void 0) {
+    return;
+  }
+  assertFrontMatterCondition(Array.isArray(reminders), "reminders must be an array");
+  for (const reminder of reminders) {
+    assertFrontMatterCondition(typeof reminder === "object" && reminder !== null && !Array.isArray(reminder), "reminders entries must be objects");
+    const reminderRecord = reminder;
+    assertFrontMatterCondition(typeof reminderRecord.at === "string", "reminder.at must be a string");
+    assertFrontMatterCondition(isTimestampLiteral(reminderRecord.at), "reminder.at must be a valid ISO timestamp");
+    assertFrontMatterCondition(typeof reminderRecord.text === "string", "reminder.text must be a string");
+    assertFrontMatterCondition(reminderRecord.text.trim().length > 0, "reminder.text must not be empty");
+  }
+}
+function assertEventStringFields(eventRecord) {
+  for (const stringField of ["title", "description", "location", "timezone"]) {
+    if (eventRecord[stringField] !== void 0) {
+      assertFrontMatterCondition(typeof eventRecord[stringField] === "string", `event.${stringField} must be a string`);
+      assertFrontMatterCondition(eventRecord[stringField].trim().length > 0, `event.${stringField} must not be empty`);
     }
   }
-  if (record.closed_at !== void 0) {
-    const closedAt = record.closed_at;
-    assertFrontMatterCondition(typeof closedAt === "string", "closed_at must be a string");
-    assertFrontMatterCondition(isTimestampLiteral(closedAt), "closed_at must be a valid ISO timestamp");
+}
+function assertEventRecurrence(eventRecord) {
+  if (eventRecord.recurrence === void 0) {
+    return;
+  }
+  assertValidRecurrenceRule(eventRecord.recurrence);
+  if (eventRecord.recurrence.until !== void 0) {
+    assertFrontMatterCondition(compareTimestampStrings(eventRecord.recurrence.until, eventRecord.start_at) >= 0, "event.recurrence.until must be at or after event.start_at");
+  }
+}
+function assertCalendarEventEntry(event) {
+  assertFrontMatterCondition(typeof event === "object" && event !== null && !Array.isArray(event), "events entries must be objects");
+  const eventRecord = event;
+  assertFrontMatterCondition(typeof eventRecord.start_at === "string", "event.start_at must be a string");
+  assertFrontMatterCondition(isTimestampLiteral(eventRecord.start_at), "event.start_at must be a valid ISO timestamp");
+  if (eventRecord.end_at !== void 0) {
+    assertFrontMatterCondition(typeof eventRecord.end_at === "string", "event.end_at must be a string");
+    assertFrontMatterCondition(isTimestampLiteral(eventRecord.end_at), "event.end_at must be a valid ISO timestamp");
+    assertFrontMatterCondition(compareTimestampStrings(eventRecord.end_at, eventRecord.start_at) > 0, "event.end_at must be after event.start_at");
+  }
+  assertEventStringFields(eventRecord);
+  if (eventRecord.all_day !== void 0) {
+    assertFrontMatterCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
+  }
+  assertEventRecurrence(eventRecord);
+}
+function assertCalendarEvents(record) {
+  const events = record.events;
+  if (events === void 0) {
+    return;
   }
+  assertFrontMatterCondition(Array.isArray(events), "events must be an array");
+  for (const event of events) {
+    assertCalendarEventEntry(event);
+  }
+}
+function assertOptionalStringFields(record) {
   for (const fieldName of ["source_type", "source_owner", "design", "external_ref"]) {
     const value = record[fieldName];
     if (value !== void 0) {
       assertFrontMatterCondition(typeof value === "string", `${fieldName} must be a string`);
     }
   }
+}
+function assertTypeOptionsField(record) {
   const typeOptions = record.type_options;
-  if (typeOptions !== void 0) {
-    assertFrontMatterCondition(typeof typeOptions === "object" && typeOptions !== null && !Array.isArray(typeOptions), "type_options must be an object");
-    for (const [optionKey, optionValue] of Object.entries(typeOptions)) {
-      assertFrontMatterCondition(optionKey.trim().length > 0, "type_options keys must be non-empty");
-      assertFrontMatterCondition(typeof optionValue === "string", "type_options values must be strings");
-      const optionText = optionValue;
-      assertFrontMatterCondition(optionText.trim().length > 0, "type_options values must be non-empty strings");
-    }
+  if (typeOptions === void 0) {
+    return;
   }
-  if (runtimeContext?.fieldRegistry) {
-    for (const definition of runtimeContext.fieldRegistry.definitions) {
-      const fieldValue = record[definition.metadata_key];
-      if (fieldValue === void 0) {
-        if (runtimeFieldRequiredForType(definition, itemType)) {
-          validationError(`missing required schema field: ${definition.metadata_key}`);
-        }
-        continue;
-      }
-      try {
-        record[definition.metadata_key] = coerceRuntimeFieldValue(definition, fieldValue, `metadata field "${definition.metadata_key}"`);
-      } catch (error) {
-        validationError(String(error?.message).replace(/^Invalid\s+/u, ""));
-      }
-    }
+  assertFrontMatterCondition(typeof typeOptions === "object" && typeOptions !== null && !Array.isArray(typeOptions), "type_options must be an object");
+  for (const [optionKey, optionValue] of Object.entries(typeOptions)) {
+    assertFrontMatterCondition(optionKey.trim().length > 0, "type_options keys must be non-empty");
+    assertFrontMatterCondition(typeof optionValue === "string", "type_options values must be strings");
+    const optionText = optionValue;
+    assertFrontMatterCondition(optionText.trim().length > 0, "type_options values must be non-empty strings");
   }
-  if (runtimeContext && runtimeContext.unknownFieldPolicy !== "allow") {
-    const knownKeys = buildKnownFrontMatterKeys(runtimeContext);
-    const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key)).sort((left, right) => left.localeCompare(right));
-    if (unknownKeys.length > 0) {
-      if (runtimeContext.unknownFieldPolicy === "reject") {
-        validationError(`unknown schema fields are not allowed: ${unknownKeys.join(", ")}`);
-      } else {
-        runtimeContext.onWarning?.(`item_unknown_schema_fields:${unknownKeys.join(",")}`);
+}
+function coerceRuntimeFrontMatterFields(record, itemType, runtimeContext) {
+  if (!runtimeContext?.fieldRegistry) {
+    return;
+  }
+  for (const definition of runtimeContext.fieldRegistry.definitions) {
+    const fieldValue = record[definition.metadata_key];
+    if (fieldValue === void 0) {
+      if (runtimeFieldRequiredForType(definition, itemType)) {
+        validationError(`missing required schema field: ${definition.metadata_key}`);
       }
+      continue;
+    }
+    try {
+      record[definition.metadata_key] = coerceRuntimeFieldValue(definition, fieldValue, `metadata field "${definition.metadata_key}"`);
+    } catch (error) {
+      validationError(String(error?.message).replace(/^Invalid\s+/u, ""));
     }
   }
 }
+function assertRuntimeUnknownFrontMatterFields(record, runtimeContext) {
+  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
+    return;
+  }
+  const knownKeys = buildKnownFrontMatterKeys(runtimeContext);
+  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key)).sort((left, right) => left.localeCompare(right));
+  if (unknownKeys.length === 0) {
+    return;
+  }
+  if (runtimeContext.unknownFieldPolicy === "reject") {
+    validationError(`unknown schema fields are not allowed: ${unknownKeys.join(", ")}`);
+  } else {
+    runtimeContext.onWarning?.(`item_unknown_schema_fields:${unknownKeys.join(",")}`);
+  }
+}
+function assertValidFrontMatter(frontMatter, runtimeContext) {
+  assertFrontMatterCondition(typeof frontMatter === "object" && frontMatter !== null && !Array.isArray(frontMatter), "front matter must be an object");
+  const record = frontMatter;
+  const itemType = assertRequiredFrontMatterFields(record);
+  assertStatusFrontMatterField(record, runtimeContext);
+  assertPriorityAndTags(record);
+  assertConfidenceFrontMatterField(record);
+  assertSeverityFrontMatterField(record);
+  assertRegressionFrontMatterField(record);
+  assertTimestampField(record, "created_at");
+  assertTimestampField(record, "updated_at");
+  if (record.deadline !== void 0) {
+    assertTimestampField(record, "deadline");
+  }
+  assertReminderEntries(record);
+  assertCalendarEvents(record);
+  assertOptionalTimestampString(record, "closed_at", "closed_at");
+  assertOptionalStringFields(record);
+  assertTypeOptionsField(record);
+  coerceRuntimeFrontMatterFields(record, itemType, runtimeContext);
+  assertRuntimeUnknownFrontMatterFields(record, runtimeContext);
+}
 function sortDependencies(values) {
   if (!values || values.length === 0)
     return void 0;
@@ -631,52 +711,38 @@ function normalizeRecurrenceRule(value) {
   return normalized;
 }
 function sortEvents(values) {
-  if (!values || values.length === 0) {
+  if (!Array.isArray(values) || values.length === 0) {
     return void 0;
   }
-  const normalized = [...values].map((value) => {
-    const event = {
-      start_at: value.start_at,
-      end_at: value.end_at || void 0,
-      title: value.title?.trim() || void 0,
-      description: value.description?.trim() || void 0,
-      location: value.location?.trim() || void 0,
-      all_day: value.all_day,
-      timezone: value.timezone?.trim() || void 0,
-      recurrence: normalizeRecurrenceRule(value.recurrence)
-    };
-    for (const [key, fieldValue] of Object.entries(event)) {
-      if (fieldValue === void 0) {
-        delete event[key];
-      }
-    }
-    return event;
-  }).sort((a, b) => {
-    const byStart = compareTimestampStrings(a.start_at, b.start_at);
-    if (byStart !== 0)
-      return byStart;
-    const byEnd = (a.end_at ?? "").localeCompare(b.end_at ?? "");
-    if (byEnd !== 0)
-      return byEnd;
-    const byTitle = (a.title ?? "").localeCompare(b.title ?? "");
-    if (byTitle !== 0)
-      return byTitle;
-    const byAllDay = Number(Boolean(a.all_day)) - Number(Boolean(b.all_day));
-    if (byAllDay !== 0)
-      return byAllDay;
-    const byTimezone = (a.timezone ?? "").localeCompare(b.timezone ?? "");
-    if (byTimezone !== 0)
-      return byTimezone;
-    const byLocation = (a.location ?? "").localeCompare(b.location ?? "");
-    if (byLocation !== 0)
-      return byLocation;
-    const byDescription = (a.description ?? "").localeCompare(b.description ?? "");
-    if (byDescription !== 0)
-      return byDescription;
-    return JSON.stringify(a.recurrence ?? {}).localeCompare(JSON.stringify(b.recurrence ?? {}));
-  });
+  const normalized = [...values].map(normalizeCalendarEvent).sort(compareCalendarEvents);
   return normalized;
 }
+function normalizeCalendarEvent(value) {
+  const event = {
+    start_at: value.start_at,
+    end_at: value.end_at || void 0,
+    title: value.title?.trim() || void 0,
+    description: value.description?.trim() || void 0,
+    location: value.location?.trim() || void 0,
+    all_day: value.all_day,
+    timezone: value.timezone?.trim() || void 0,
+    recurrence: normalizeRecurrenceRule(value.recurrence)
+  };
+  deleteUndefinedFields(event);
+  return event;
+}
+function compareCalendarEvents(a, b) {
+  return firstNonZeroComparison([
+    compareTimestampStrings(a.start_at, b.start_at),
+    (a.end_at ?? "").localeCompare(b.end_at ?? ""),
+    (a.title ?? "").localeCompare(b.title ?? ""),
+    Number(Boolean(a.all_day)) - Number(Boolean(b.all_day)),
+    (a.timezone ?? "").localeCompare(b.timezone ?? ""),
+    (a.location ?? "").localeCompare(b.location ?? ""),
+    (a.description ?? "").localeCompare(b.description ?? ""),
+    JSON.stringify(a.recurrence ?? {}).localeCompare(JSON.stringify(b.recurrence ?? {}))
+  ]);
+}
 function normalizeFiles(values) {
   if (!values || values.length === 0)
     return void 0;
@@ -689,83 +755,140 @@ function normalizeFiles(values) {
 function normalizeTestRunSummaries(values) {
   if (!values || values.length === 0)
     return void 0;
-  const normalized = values.map((value) => {
-    const runId = typeof value.run_id === "string" ? value.run_id.trim() : "";
-    const kind = value.kind === "test" || value.kind === "test-all" ? value.kind : "test";
-    const status = value.status === "passed" || value.status === "failed" || value.status === "stopped" || value.status === "canceled" ? value.status : "failed";
-    const startedAt = typeof value.started_at === "string" ? value.started_at : "";
-    const finishedAt = typeof value.finished_at === "string" ? value.finished_at : "";
-    const recordedAt = typeof value.recorded_at === "string" ? value.recorded_at : "";
-    const passed = typeof value.passed === "number" && Number.isFinite(value.passed) ? Math.max(0, Math.floor(value.passed)) : 0;
-    const failed = typeof value.failed === "number" && Number.isFinite(value.failed) ? Math.max(0, Math.floor(value.failed)) : 0;
-    const skipped = typeof value.skipped === "number" && Number.isFinite(value.skipped) ? Math.max(0, Math.floor(value.skipped)) : 0;
-    return {
-      run_id: runId,
-      kind,
-      status,
-      started_at: startedAt,
-      finished_at: finishedAt,
-      recorded_at: recordedAt,
-      attempt: typeof value.attempt === "number" && Number.isFinite(value.attempt) && value.attempt >= 1 ? Math.floor(value.attempt) : void 0,
-      resumed_from: value.resumed_from?.trim() || void 0,
-      passed,
-      failed,
-      skipped,
-      items: typeof value.items === "number" && Number.isFinite(value.items) && value.items >= 0 ? Math.floor(value.items) : void 0,
-      linked_tests: typeof value.linked_tests === "number" && Number.isFinite(value.linked_tests) && value.linked_tests >= 0 ? Math.floor(value.linked_tests) : void 0,
-      fail_on_skipped_triggered: value.fail_on_skipped_triggered === true ? true : void 0
-    };
-  }).filter((value) => value.run_id.length > 0 && value.started_at.length > 0 && value.finished_at.length > 0 && value.recorded_at.length > 0).sort((a, b) => firstNonZeroComparison([
+  const normalized = values.map(normalizeTestRunSummary).filter((value) => value.run_id.length > 0 && value.started_at.length > 0 && value.finished_at.length > 0 && value.recorded_at.length > 0).sort((a, b) => firstNonZeroComparison([
     compareTimestampStrings(a.recorded_at, b.recorded_at),
     a.run_id.localeCompare(b.run_id),
     a.kind.localeCompare(b.kind)
   ]));
   return normalized.length > 0 ? normalized : void 0;
 }
+function normalizeNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+function normalizePositiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : void 0;
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function normalizeTestRunSummary(value) {
+  const runId = typeof value.run_id === "string" ? value.run_id.trim() : "";
+  const kind = value.kind === "test" || value.kind === "test-all" ? value.kind : "test";
+  const status = ITEM_TEST_RUN_STATUS_VALUES.has(value.status) ? value.status : "failed";
+  const summary = {
+    run_id: runId,
+    kind,
+    status,
+    started_at: stringOrEmpty(value.started_at),
+    finished_at: stringOrEmpty(value.finished_at),
+    recorded_at: stringOrEmpty(value.recorded_at),
+    attempt: normalizePositiveInteger(value.attempt),
+    resumed_from: value.resumed_from?.trim() || void 0,
+    passed: normalizeNonNegativeInteger(value.passed) ?? 0,
+    failed: normalizeNonNegativeInteger(value.failed) ?? 0,
+    skipped: normalizeNonNegativeInteger(value.skipped) ?? 0,
+    items: normalizeNonNegativeInteger(value.items),
+    linked_tests: normalizeNonNegativeInteger(value.linked_tests),
+    fail_on_skipped_triggered: value.fail_on_skipped_triggered === true ? true : void 0
+  };
+  deleteUndefinedFields(summary);
+  return summary;
+}
 function sortTests(values) {
-  if (!values || values.length === 0)
+  if (!Array.isArray(values) || values.length === 0)
     return void 0;
-  return [...values].map((value) => ({
+  return [...values].map(normalizeLinkedTest).sort(compareLinkedTests);
+}
+function normalizeTrimmedStringList(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const normalized = [
+    ...new Set(value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0))
+  ].sort((a, b) => a.localeCompare(b));
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isPlainObjectRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isUnsafeObjectKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function normalizeStringRecord(value) {
+  if (!isPlainObjectRecord(value)) {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([key, recordValue]) => [key.trim(), String(recordValue).trim()]).filter(([key, recordValue]) => key.length > 0 && !isUnsafeObjectKey(key) && recordValue.length > 0).sort(([left], [right]) => left.localeCompare(right));
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeNumericRecord(value) {
+  if (!isPlainObjectRecord(value)) {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([key, recordValue]) => [key.trim(), Number(recordValue)]).filter(([key, recordValue]) => key.length > 0 && !isUnsafeObjectKey(key) && Number.isFinite(recordValue)).sort(([left], [right]) => left.localeCompare(right));
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeLinkedTestContextMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized || !LINKED_TEST_PM_CONTEXT_MODE_VALUES.has(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeLinkedTest(value) {
+  const test = {
     command: value.command?.trim() || void 0,
     path: value.path ? normalizePathValue(value.path) : void 0,
     scope: value.scope,
     timeout_seconds: typeof value.timeout_seconds === "number" && Number.isFinite(value.timeout_seconds) && value.timeout_seconds > 0 ? value.timeout_seconds : void 0,
-    pm_context_mode: (() => {
-      const normalized = value.pm_context_mode?.trim().toLowerCase();
-      if (!normalized || !LINKED_TEST_PM_CONTEXT_MODE_VALUES.has(normalized)) {
-        return void 0;
-      }
-      return normalized;
-    })(),
-    env_set: value.env_set ? Object.fromEntries(Object.entries(value.env_set).map(([key, envValue]) => [key.trim(), String(envValue).trim()]).filter(([key, envValue]) => key.length > 0 && envValue.length > 0).sort(([left], [right]) => left.localeCompare(right))) : void 0,
-    env_clear: value.env_clear ? [...new Set(value.env_clear.map((entry) => entry.trim()).filter((entry) => entry.length > 0))].sort((a, b) => a.localeCompare(b)) : void 0,
+    pm_context_mode: normalizeLinkedTestContextMode(value.pm_context_mode),
+    env_set: normalizeStringRecord(value.env_set),
+    env_clear: normalizeTrimmedStringList(value.env_clear),
     shared_host_safe: value.shared_host_safe === true ? true : void 0,
-    assert_stdout_contains: value.assert_stdout_contains ? [...new Set(value.assert_stdout_contains.map((entry) => entry.trim()).filter((entry) => entry.length > 0))].sort((a, b) => a.localeCompare(b)) : void 0,
-    assert_stdout_regex: value.assert_stdout_regex ? [...new Set(value.assert_stdout_regex.map((entry) => entry.trim()).filter((entry) => entry.length > 0))].sort((a, b) => a.localeCompare(b)) : void 0,
-    assert_stderr_contains: value.assert_stderr_contains ? [...new Set(value.assert_stderr_contains.map((entry) => entry.trim()).filter((entry) => entry.length > 0))].sort((a, b) => a.localeCompare(b)) : void 0,
-    assert_stderr_regex: value.assert_stderr_regex ? [...new Set(value.assert_stderr_regex.map((entry) => entry.trim()).filter((entry) => entry.length > 0))].sort((a, b) => a.localeCompare(b)) : void 0,
-    assert_stdout_min_lines: typeof value.assert_stdout_min_lines === "number" && Number.isFinite(value.assert_stdout_min_lines) && value.assert_stdout_min_lines >= 0 ? Math.floor(value.assert_stdout_min_lines) : void 0,
-    assert_json_field_equals: value.assert_json_field_equals ? Object.fromEntries(Object.entries(value.assert_json_field_equals).map(([key, expectedValue]) => [key.trim(), String(expectedValue).trim()]).filter(([key, expectedValue]) => key.length > 0 && expectedValue.length > 0).sort(([left], [right]) => left.localeCompare(right))) : void 0,
-    assert_json_field_gte: value.assert_json_field_gte ? Object.fromEntries(Object.entries(value.assert_json_field_gte).map(([key, expectedValue]) => [key.trim(), Number(expectedValue)]).filter(([key, expectedValue]) => key.length > 0 && Number.isFinite(expectedValue)).sort(([left], [right]) => left.localeCompare(right))) : void 0,
+    assert_stdout_contains: normalizeTrimmedStringList(value.assert_stdout_contains),
+    assert_stdout_regex: normalizeTrimmedStringList(value.assert_stdout_regex),
+    assert_stderr_contains: normalizeTrimmedStringList(value.assert_stderr_contains),
+    assert_stderr_regex: normalizeTrimmedStringList(value.assert_stderr_regex),
+    assert_stdout_min_lines: normalizeNonNegativeInteger(value.assert_stdout_min_lines),
+    assert_json_field_equals: normalizeStringRecord(value.assert_json_field_equals),
+    assert_json_field_gte: normalizeNumericRecord(value.assert_json_field_gte),
     note: value.note?.trim() || void 0
-  })).sort((a, b) => firstNonZeroComparison([
+  };
+  deleteUndefinedFields(test);
+  return test;
+}
+function compareLinkedTests(a, b) {
+  return firstNonZeroComparison([
     a.scope.localeCompare(b.scope),
-    (a.path ?? "").localeCompare(b.path ?? ""),
-    (a.command ?? "").localeCompare(b.command ?? ""),
-    (a.timeout_seconds ?? 0) - (b.timeout_seconds ?? 0),
-    (a.pm_context_mode ?? "").localeCompare(b.pm_context_mode ?? ""),
+    compareOptionalStrings(a.path, b.path),
+    compareOptionalStrings(a.command, b.command),
+    compareOptionalNumbers(a.timeout_seconds, b.timeout_seconds),
+    compareOptionalStrings(a.pm_context_mode, b.pm_context_mode),
     Number(Boolean(a.shared_host_safe)) - Number(Boolean(b.shared_host_safe)),
-    JSON.stringify(a.env_clear ?? []).localeCompare(JSON.stringify(b.env_clear ?? [])),
-    JSON.stringify(a.env_set ?? {}).localeCompare(JSON.stringify(b.env_set ?? {})),
-    JSON.stringify(a.assert_stdout_contains ?? []).localeCompare(JSON.stringify(b.assert_stdout_contains ?? [])),
-    JSON.stringify(a.assert_stdout_regex ?? []).localeCompare(JSON.stringify(b.assert_stdout_regex ?? [])),
-    JSON.stringify(a.assert_stderr_contains ?? []).localeCompare(JSON.stringify(b.assert_stderr_contains ?? [])),
-    JSON.stringify(a.assert_stderr_regex ?? []).localeCompare(JSON.stringify(b.assert_stderr_regex ?? [])),
-    (a.assert_stdout_min_lines ?? 0) - (b.assert_stdout_min_lines ?? 0),
-    JSON.stringify(a.assert_json_field_equals ?? {}).localeCompare(JSON.stringify(b.assert_json_field_equals ?? {})),
-    JSON.stringify(a.assert_json_field_gte ?? {}).localeCompare(JSON.stringify(b.assert_json_field_gte ?? {})),
-    (a.note ?? "").localeCompare(b.note ?? "")
-  ]));
+    compareJsonValues(a.env_clear, b.env_clear, []),
+    compareJsonValues(a.env_set, b.env_set, {}),
+    compareJsonValues(a.assert_stdout_contains, b.assert_stdout_contains, []),
+    compareJsonValues(a.assert_stdout_regex, b.assert_stdout_regex, []),
+    compareJsonValues(a.assert_stderr_contains, b.assert_stderr_contains, []),
+    compareJsonValues(a.assert_stderr_regex, b.assert_stderr_regex, []),
+    compareOptionalNumbers(a.assert_stdout_min_lines, b.assert_stdout_min_lines),
+    compareJsonValues(a.assert_json_field_equals, b.assert_json_field_equals, {}),
+    compareJsonValues(a.assert_json_field_gte, b.assert_json_field_gte, {}),
+    compareOptionalStrings(a.note, b.note)
+  ]);
+}
+function compareOptionalStrings(left, right) {
+  return (left ?? "").localeCompare(right ?? "");
+}
+function compareOptionalNumbers(left, right) {
+  return (left ?? 0) - (right ?? 0);
+}
+function compareJsonValues(left, right, fallback) {
+  return JSON.stringify(left ?? fallback).localeCompare(JSON.stringify(right ?? fallback));
 }
 function sortDocs(values) {
   if (!values || values.length === 0)
@@ -878,65 +1001,71 @@ function normalizePlanStepDocs(value) {
   }
   return out.length > 0 ? out : void 0;
 }
+function normalizePlanStepEntry(entry) {
+  if (entry === null || typeof entry !== "object") {
+    return void 0;
+  }
+  const record = entry;
+  const id = trimStringOrUndefined(record.id);
+  const title = trimStringOrUndefined(record.title);
+  const statusRaw = trimStringOrUndefined(record.status);
+  const status = statusRaw && PLAN_STEP_STATUS_SET.has(statusRaw) ? statusRaw : void 0;
+  const orderRaw = record.order;
+  const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) ? orderRaw : typeof orderRaw === "string" && orderRaw.trim().length > 0 ? Number(orderRaw) : Number.NaN;
+  const created_at = typeof record.created_at === "string" ? record.created_at : "";
+  const updated_at = typeof record.updated_at === "string" ? record.updated_at : "";
+  if (!id || !title || !status || !Number.isFinite(order) || !created_at || !updated_at) {
+    return void 0;
+  }
+  const step = {
+    id,
+    order,
+    title,
+    status,
+    created_at,
+    updated_at
+  };
+  applyPlanStepOptionalFields(step, record);
+  return step;
+}
+function applyPlanStepOptionalFields(step, record) {
+  const stringFields = [
+    ["body", "body"],
+    ["owner", "owner"],
+    ["evidence", "evidence"],
+    ["blocked_reason", "blocked_reason"],
+    ["superseded_by", "superseded_by"]
+  ];
+  for (const [target, source] of stringFields) {
+    const value = trimStringOrUndefined(record[source]);
+    if (value) {
+      step[target] = value;
+    }
+  }
+  const completedAt = typeof record.completed_at === "string" ? record.completed_at : void 0;
+  if (completedAt && completedAt.length > 0) {
+    step.completed_at = completedAt;
+  }
+  const collectionFields = [
+    ["linked_items", "linked_items", normalizePlanStepLinks],
+    ["files", "files", normalizePlanStepFiles],
+    ["tests", "tests", normalizePlanStepTests],
+    ["docs", "docs", normalizePlanStepDocs]
+  ];
+  for (const [target, source, normalize] of collectionFields) {
+    const value = normalize(record[source]);
+    if (value) {
+      step[target] = value;
+    }
+  }
+}
 function normalizePlanSteps(value) {
   if (!Array.isArray(value))
     return void 0;
-  const out = [];
-  for (const entry of value) {
-    if (entry === null || typeof entry !== "object")
-      continue;
-    const record = entry;
-    const id = trimStringOrUndefined(record.id);
-    const title = trimStringOrUndefined(record.title);
-    const status = trimStringOrUndefined(record.status);
-    const orderRaw = record.order;
-    const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) ? orderRaw : Number(orderRaw);
-    if (!id || !title || !status || !Number.isFinite(order))
-      continue;
-    const created_at = typeof record.created_at === "string" ? record.created_at : "";
-    const updated_at = typeof record.updated_at === "string" ? record.updated_at : "";
-    if (!created_at || !updated_at)
-      continue;
-    const step = {
-      id,
-      order,
-      title,
-      status,
-      created_at,
-      updated_at
-    };
-    const body = trimStringOrUndefined(record.body);
-    if (body)
-      step.body = body;
-    const owner = trimStringOrUndefined(record.owner);
-    if (owner)
-      step.owner = owner;
-    const evidence = trimStringOrUndefined(record.evidence);
-    if (evidence)
-      step.evidence = evidence;
-    const blockedReason = trimStringOrUndefined(record.blocked_reason);
-    if (blockedReason)
-      step.blocked_reason = blockedReason;
-    const supersededBy = trimStringOrUndefined(record.superseded_by);
-    if (supersededBy)
-      step.superseded_by = supersededBy;
-    const completedAt = typeof record.completed_at === "string" ? record.completed_at : void 0;
-    if (completedAt && completedAt.length > 0)
-      step.completed_at = completedAt;
-    const links = normalizePlanStepLinks(record.linked_items);
-    if (links)
-      step.linked_items = links;
-    const files = normalizePlanStepFiles(record.files);
-    if (files)
-      step.files = files;
-    const tests = normalizePlanStepTests(record.tests);
-    if (tests)
-      step.tests = tests;
-    const docs = normalizePlanStepDocs(record.docs);
-    if (docs)
-      step.docs = docs;
-    out.push(step);
-  }
+  const out = value.flatMap((entry) => {
+    const step = normalizePlanStepEntry(entry);
+    return step ? [step] : [];
+  });
   out.sort((left, right) => left.order - right.order);
   return out.length > 0 ? out : void 0;
 }
@@ -1056,6 +1185,46 @@ function normalizeSeverityValue(value) {
   }
   return void 0;
 }
+function emptyStringToUndefined(value) {
+  return value || void 0;
+}
+function copyExtensionFrontMatterFields(normalized, source) {
+  const targetRecord = normalized;
+  const sourceRecord = source;
+  for (const [key, value] of Object.entries(sourceRecord)) {
+    if (isUnsafeObjectKey(key) || Object.prototype.hasOwnProperty.call(targetRecord, key) || value === void 0) {
+      continue;
+    }
+    targetRecord[key] = value;
+  }
+}
+function coerceNormalizedRuntimeFields(normalized, runtimeContext) {
+  if (!runtimeContext?.fieldRegistry) {
+    return;
+  }
+  const record = normalized;
+  for (const definition of runtimeContext.fieldRegistry.definitions) {
+    const currentValue = record[definition.metadata_key];
+    if (currentValue === void 0) {
+      continue;
+    }
+    record[definition.metadata_key] = coerceRuntimeFieldValue(definition, currentValue, `metadata field "${definition.metadata_key}"`);
+  }
+}
+function assertNormalizedUnknownFields(normalized, runtimeContext) {
+  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
+    return;
+  }
+  const knownKeys = buildKnownFrontMatterKeys(runtimeContext);
+  const record = normalized;
+  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key)).sort((left, right) => left.localeCompare(right));
+  if (unknownKeys.length > 0 && runtimeContext.unknownFieldPolicy === "reject") {
+    validationError(`unknown schema fields are not allowed: ${unknownKeys.join(", ")}`);
+  }
+  if (unknownKeys.length > 0) {
+    runtimeContext.onWarning?.(`item_unknown_schema_fields:${unknownKeys.join(",")}`);
+  }
+}
 function normalizeFrontMatter(frontMatter, options = {}) {
   const runtimeContext = resolveRuntimeSchemaValidationContext(options);
   const normalizedStatus = normalizeStatusInput(frontMatter.status, runtimeContext?.statusRegistry) ?? frontMatter.status;
@@ -1066,7 +1235,7 @@ function normalizeFrontMatter(frontMatter, options = {}) {
     description: frontMatter.description,
     type: frontMatter.type,
     pm_format_version: normalizeItemFormatVersion(frontMatter.pm_format_version),
-    source_type: frontMatter.source_type?.trim() || void 0,
+    source_type: trimStringOrUndefined(frontMatter.source_type),
     type_options: normalizeTypeOptions(frontMatter.type_options),
     status: normalizedStatus,
     priority: frontMatter.priority,
@@ -1081,47 +1250,47 @@ function normalizeFrontMatter(frontMatter, options = {}) {
     tests: sortTests(frontMatter.tests),
     test_runs: normalizeTestRunSummaries(frontMatter.test_runs),
     docs: sortDocs(frontMatter.docs),
-    deadline: frontMatter.deadline || void 0,
+    deadline: emptyStringToUndefined(frontMatter.deadline),
     reminders: sortReminders(frontMatter.reminders),
     events: sortEvents(frontMatter.events),
-    closed_at: frontMatter.closed_at || void 0,
-    assignee: frontMatter.assignee?.trim() || void 0,
-    source_owner: frontMatter.source_owner?.trim() || void 0,
-    author: frontMatter.author || void 0,
+    closed_at: emptyStringToUndefined(frontMatter.closed_at),
+    assignee: trimStringOrUndefined(frontMatter.assignee),
+    source_owner: trimStringOrUndefined(frontMatter.source_owner),
+    author: emptyStringToUndefined(frontMatter.author),
     estimated_minutes: frontMatter.estimated_minutes,
     acceptance_criteria: frontMatter.acceptance_criteria ?? void 0,
     design: frontMatter.design ?? void 0,
     external_ref: frontMatter.external_ref ?? void 0,
-    definition_of_ready: frontMatter.definition_of_ready?.trim() || void 0,
+    definition_of_ready: trimStringOrUndefined(frontMatter.definition_of_ready),
     order: frontMatter.order,
-    goal: frontMatter.goal?.trim() || void 0,
-    objective: frontMatter.objective?.trim() || void 0,
-    value: frontMatter.value?.trim() || void 0,
-    impact: frontMatter.impact?.trim() || void 0,
-    outcome: frontMatter.outcome?.trim() || void 0,
-    why_now: frontMatter.why_now?.trim() || void 0,
-    parent: frontMatter.parent?.trim() || void 0,
-    reviewer: frontMatter.reviewer?.trim() || void 0,
+    goal: trimStringOrUndefined(frontMatter.goal),
+    objective: trimStringOrUndefined(frontMatter.objective),
+    value: trimStringOrUndefined(frontMatter.value),
+    impact: trimStringOrUndefined(frontMatter.impact),
+    outcome: trimStringOrUndefined(frontMatter.outcome),
+    why_now: trimStringOrUndefined(frontMatter.why_now),
+    parent: trimStringOrUndefined(frontMatter.parent),
+    reviewer: trimStringOrUndefined(frontMatter.reviewer),
     risk: frontMatter.risk ?? void 0,
     confidence: normalizeConfidenceValue(frontMatter.confidence),
-    sprint: frontMatter.sprint?.trim() || void 0,
-    release: frontMatter.release?.trim() || void 0,
-    blocked_by: frontMatter.blocked_by?.trim() || void 0,
-    blocked_reason: frontMatter.blocked_reason?.trim() || void 0,
-    unblock_note: frontMatter.unblock_note?.trim() || void 0,
-    reporter: frontMatter.reporter?.trim() || void 0,
+    sprint: trimStringOrUndefined(frontMatter.sprint),
+    release: trimStringOrUndefined(frontMatter.release),
+    blocked_by: trimStringOrUndefined(frontMatter.blocked_by),
+    blocked_reason: trimStringOrUndefined(frontMatter.blocked_reason),
+    unblock_note: trimStringOrUndefined(frontMatter.unblock_note),
+    reporter: trimStringOrUndefined(frontMatter.reporter),
     severity: normalizeSeverityValue(frontMatter.severity),
-    environment: frontMatter.environment?.trim() || void 0,
-    repro_steps: frontMatter.repro_steps?.trim() || void 0,
-    resolution: frontMatter.resolution?.trim() || void 0,
-    expected_result: frontMatter.expected_result?.trim() || void 0,
-    actual_result: frontMatter.actual_result?.trim() || void 0,
-    affected_version: frontMatter.affected_version?.trim() || void 0,
-    fixed_version: frontMatter.fixed_version?.trim() || void 0,
-    component: frontMatter.component?.trim() || void 0,
+    environment: trimStringOrUndefined(frontMatter.environment),
+    repro_steps: trimStringOrUndefined(frontMatter.repro_steps),
+    resolution: trimStringOrUndefined(frontMatter.resolution),
+    expected_result: trimStringOrUndefined(frontMatter.expected_result),
+    actual_result: trimStringOrUndefined(frontMatter.actual_result),
+    affected_version: trimStringOrUndefined(frontMatter.affected_version),
+    fixed_version: trimStringOrUndefined(frontMatter.fixed_version),
+    component: trimStringOrUndefined(frontMatter.component),
     regression: frontMatter.regression,
-    customer_impact: frontMatter.customer_impact?.trim() || void 0,
-    close_reason: frontMatter.close_reason || void 0,
+    customer_impact: trimStringOrUndefined(frontMatter.customer_impact),
+    close_reason: emptyStringToUndefined(frontMatter.close_reason),
     plan_mode: trimStringOrUndefined(frontMatter.plan_mode),
     plan_scope: trimStringOrUndefined(frontMatter.plan_scope),
     plan_harness: trimStringOrUndefined(frontMatter.plan_harness),
@@ -1131,36 +1300,10 @@ function normalizeFrontMatter(frontMatter, options = {}) {
     plan_discoveries: normalizePlanDiscoveries(frontMatter.plan_discoveries),
     plan_validation: normalizePlanValidation(frontMatter.plan_validation)
   };
-  const sourceRecord = frontMatter;
-  for (const [key, value] of Object.entries(sourceRecord)) {
-    if (Object.prototype.hasOwnProperty.call(normalized, key) || value === void 0) {
-      continue;
-    }
-    normalized[key] = value;
-  }
-  if (runtimeContext?.fieldRegistry) {
-    for (const definition of runtimeContext.fieldRegistry.definitions) {
-      const currentValue = normalized[definition.metadata_key];
-      if (currentValue === void 0) {
-        continue;
-      }
-      normalized[definition.metadata_key] = coerceRuntimeFieldValue(definition, currentValue, `metadata field "${definition.metadata_key}"`);
-    }
-  }
-  if (runtimeContext && runtimeContext.unknownFieldPolicy !== "allow") {
-    const knownKeys = buildKnownFrontMatterKeys(runtimeContext);
-    const unknownKeys = Object.keys(normalized).filter((key) => !knownKeys.has(key)).sort((left, right) => left.localeCompare(right));
-    if (unknownKeys.length > 0) {
-      if (runtimeContext.unknownFieldPolicy === "reject") {
-        validationError(`unknown schema fields are not allowed: ${unknownKeys.join(", ")}`);
-      }
-    }
-  }
-  for (const [key, value] of Object.entries(normalized)) {
-    if (value === void 0) {
-      delete normalized[key];
-    }
-  }
+  copyExtensionFrontMatterFields(normalized, frontMatter);
+  coerceNormalizedRuntimeFields(normalized, runtimeContext);
+  assertNormalizedUnknownFields(normalized, runtimeContext);
+  deleteUndefinedFields(normalized);
   return normalized;
 }
 function orderFrontMatter(frontMatter) {
@@ -1234,6 +1377,9 @@ function stripLeadingYamlDocument(content) {
   }
   return { content: normalizedContent, stripped: false };
 }
+function normalizeParsedFrontMatter(frontMatter, options) {
+  return normalizeFrontMatter(frontMatter, { ...options, onWarning: void 0 });
+}
 function parseJsonMarkdownItemDocument(content, runtimeContext, options = {}) {
   const normalized = stripLeadingYamlDocument(content);
   if (normalized.stripped) {
@@ -1255,7 +1401,7 @@ function parseJsonMarkdownItemDocument(content, runtimeContext, options = {}) {
   }
   assertValidFrontMatter(parsed, runtimeContext);
   return {
-    metadata: normalizeFrontMatter(parsed, options),
+    metadata: normalizeParsedFrontMatter(parsed, options),
     body: normalizeBody(body)
   };
 }
@@ -1272,7 +1418,7 @@ function parseToonItemDocument(content, runtimeContext, options = {}) {
     assertValidFrontMatter(record.front_matter, runtimeContext);
     assertFrontMatterCondition(record.body === void 0 || typeof record.body === "string", "TOON item document body must be a string");
     return {
-      metadata: normalizeFrontMatter(record.front_matter, options),
+      metadata: normalizeParsedFrontMatter(record.front_matter, options),
       body: normalizeBody(typeof record.body === "string" ? record.body : "")
     };
   }
@@ -1280,7 +1426,7 @@ function parseToonItemDocument(content, runtimeContext, options = {}) {
   assertFrontMatterCondition(body === void 0 || typeof body === "string", "TOON item document body must be a string");
   assertValidFrontMatter(frontMatterRecord, runtimeContext);
   return {
-    metadata: normalizeFrontMatter(frontMatterRecord, options),
+    metadata: normalizeParsedFrontMatter(frontMatterRecord, options),
     body: normalizeBody(typeof body === "string" ? body : "")
   };
 }
@@ -1348,6 +1494,6 @@ export {
   serializeItemDocument,
   canonicalDocument
 };
-//# sourceMappingURL=chunk-V3KLX7U7.js.map
+//# sourceMappingURL=chunk-KN3URLKS.js.map
 
-//# debugId=da8f95fe-2b22-59c6-af82-e0bd090502e4
+//# debugId=89ae7463-1314-574c-9158-0967e6d9c589