@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/core/item/item-format.js

@@ -4,9 +4,9 @@
  * Defines item parsing, formatting, and lifecycle helpers for Item Format.
  */
 
-!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]="777ea2a9-5aa6-5a90-abb5-a0b6052645f2")}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]="84d024fa-403c-5a85-8c12-4e823afa4fc9")}catch(e){}}();
 import { encode as encodeToon } from "@toon-format/toon";
-import { CONFIDENCE_TEXT_VALUES, ISSUE_SEVERITY_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, STATUS_VALUES, weekdayOrderIndex, } from "../../types/index.js";
+import { CONFIDENCE_TEXT_VALUES, ISSUE_SEVERITY_VALUES, PLAN_STEP_STATUS_VALUES, RECURRENCE_FREQUENCY_VALUES, RECURRENCE_WEEKDAY_VALUES, STATUS_VALUES, weekdayOrderIndex, } from "../../types/index.js";
 import { coerceRuntimeFieldValue } from "../schema/runtime-field-values.js";
 import { resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, } from "../schema/runtime-schema.js";
 import { BASELINE_ITEM_FORMAT_VERSION, normalizeItemFormatVersion } from "./item-format-version.js";
@@ -18,6 +18,8 @@ import { PmCliError } from "../shared/errors.js";
 import { orderObject } from "../shared/serialization.js";
 import { compareTimestampStrings, isTimestampLiteral } from "../shared/time.js";
 const LINKED_TEST_PM_CONTEXT_MODE_VALUES = new Set(["schema", "tracker", "auto"]);
+const ITEM_TEST_RUN_STATUS_VALUES = new Set(["passed", "failed", "stopped", "canceled"]);
+const PLAN_STEP_STATUS_SET = new Set(PLAN_STEP_STATUS_VALUES);
 function normalizePathValue(value) {
     return value.replaceAll("\\", "/");
 }
@@ -29,6 +31,13 @@ function firstNonZeroComparison(comparisons) {
     }
     return 0;
 }
+function deleteUndefinedFields(record) {
+    for (const [key, value] of Object.entries(record)) {
+        if (value === undefined) {
+            delete record[key];
+        }
+    }
+}
 const REQUIRED_STRING_FIELDS = [
     "id",
     "title",
@@ -82,49 +91,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 === undefined) {
+        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 === undefined) {
+        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 === undefined) {
+        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 === undefined) {
+        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 === undefined) {
+        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 !== undefined) {
-        assertFrontMatterCondition(typeof recurrenceRecord.interval === "number" &&
-            Number.isInteger(recurrenceRecord.interval) &&
-            recurrenceRecord.interval >= 1, "event.recurrence.interval must be an integer >= 1");
-    }
-    if (recurrenceRecord.count !== undefined) {
-        assertFrontMatterCondition(typeof recurrenceRecord.count === "number" && Number.isInteger(recurrenceRecord.count) && recurrenceRecord.count >= 1, "event.recurrence.count must be an integer >= 1");
-    }
-    if (recurrenceRecord.until !== undefined) {
-        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 !== undefined) {
-        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 !== undefined) {
-        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 !== undefined) {
-        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");
-        }
-    }
+    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 assertValidFrontMatter(frontMatter, runtimeContext) {
-    assertFrontMatterCondition(typeof frontMatter === "object" && frontMatter !== null && !Array.isArray(frontMatter), "front matter must be an object");
-    const record = frontMatter;
+function assertRequiredFrontMatterFields(record) {
     for (const fieldName of REQUIRED_STRING_FIELDS) {
         assertFrontMatterCondition(typeof record[fieldName] === "string", `${fieldName} is required and must be a string`);
     }
@@ -134,6 +159,9 @@ function assertValidFrontMatter(frontMatter, runtimeContext) {
     if (formatVersion !== undefined) {
         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;
@@ -142,6 +170,8 @@ function assertValidFrontMatter(frontMatter, runtimeContext) {
         ? statusRegistry.definitions.map((definition) => definition.id)
         : [...STATUS_VALUES];
     assertFrontMatterCondition(normalizedStatus !== undefined, `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;
@@ -149,133 +179,178 @@ 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 !== undefined) {
-        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 === undefined) {
+        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 !== undefined) {
-        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 !== undefined) {
-        if (typeof regression !== "boolean") {
-            validationError("regression must be a boolean");
-        }
+    if (severity === undefined) {
+        return;
     }
-    assertTimestampField(record, "created_at");
-    assertTimestampField(record, "updated_at");
-    if (record.deadline !== undefined) {
-        assertTimestampField(record, "deadline");
+    if (typeof severity !== "string") {
+        validationError("severity must be a string");
     }
-    if (record.reminders !== undefined) {
-        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 !== undefined && typeof record.regression !== "boolean") {
+        validationError("regression must be a boolean");
     }
-    if (record.events !== undefined) {
-        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 !== undefined) {
-                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] !== undefined) {
-                    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 !== undefined) {
-                assertFrontMatterCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
-            }
-            if (eventRecord.recurrence !== undefined) {
-                assertValidRecurrenceRule(eventRecord.recurrence);
-                if (eventRecord.recurrence.until !== undefined) {
-                    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 === undefined) {
+        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] !== undefined) {
+            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 !== undefined) {
-        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 === undefined) {
+        return;
+    }
+    assertValidRecurrenceRule(eventRecord.recurrence);
+    if (eventRecord.recurrence.until !== undefined) {
+        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 !== undefined) {
+        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 !== undefined) {
+        assertFrontMatterCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
+    }
+    assertEventRecurrence(eventRecord);
+}
+function assertCalendarEvents(record) {
+    const events = record.events;
+    if (events === undefined) {
+        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 !== undefined) {
             assertFrontMatterCondition(typeof value === "string", `${fieldName} must be a string`);
         }
     }
+}
+function assertTypeOptionsField(record) {
     const typeOptions = record.type_options;
-    if (typeOptions !== undefined) {
-        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 === undefined) {
+        return;
     }
-    if (runtimeContext?.fieldRegistry) {
-        for (const definition of runtimeContext.fieldRegistry.definitions) {
-            const fieldValue = record[definition.metadata_key];
-            if (fieldValue === undefined) {
-                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 === undefined) {
+            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 !== undefined) {
+        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 undefined;
@@ -365,54 +440,38 @@ function normalizeRecurrenceRule(value) {
     return normalized;
 }
 function sortEvents(values) {
-    if (!values || values.length === 0) {
+    if (!Array.isArray(values) || values.length === 0) {
         return undefined;
     }
-    const normalized = [...values]
-        .map((value) => {
-        const event = {
-            start_at: value.start_at,
-            end_at: value.end_at || undefined,
-            title: value.title?.trim() || undefined,
-            description: value.description?.trim() || undefined,
-            location: value.location?.trim() || undefined,
-            all_day: value.all_day,
-            timezone: value.timezone?.trim() || undefined,
-            recurrence: normalizeRecurrenceRule(value.recurrence),
-        };
-        for (const [key, fieldValue] of Object.entries(event)) {
-            if (fieldValue === undefined) {
-                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 || undefined,
+        title: value.title?.trim() || undefined,
+        description: value.description?.trim() || undefined,
+        location: value.location?.trim() || undefined,
+        all_day: value.all_day,
+        timezone: value.timezone?.trim() || undefined,
+        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 undefined;
@@ -427,41 +486,7 @@ function normalizeTestRunSummaries(values) {
     if (!values || values.length === 0)
         return undefined;
     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)
-                : undefined,
-            resumed_from: value.resumed_from?.trim() || undefined,
-            passed,
-            failed,
-            skipped,
-            items: typeof value.items === "number" && Number.isFinite(value.items) && value.items >= 0
-                ? Math.floor(value.items)
-                : undefined,
-            linked_tests: typeof value.linked_tests === "number" && Number.isFinite(value.linked_tests) && value.linked_tests >= 0
-                ? Math.floor(value.linked_tests)
-                : undefined,
-            fail_on_skipped_triggered: value.fail_on_skipped_triggered === true ? true : undefined,
-        };
-    })
+        .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),
@@ -470,83 +495,144 @@ function normalizeTestRunSummaries(values) {
     ]));
     return normalized.length > 0 ? normalized : undefined;
 }
+function normalizeNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : undefined;
+}
+function normalizePositiveInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : undefined;
+}
+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() || undefined,
+        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 : undefined,
+    };
+    deleteUndefinedFields(summary);
+    return summary;
+}
 function sortTests(values) {
-    if (!values || values.length === 0)
+    if (!Array.isArray(values) || values.length === 0)
         return undefined;
-    return [...values]
-        .map((value) => ({
+    return [...values].map(normalizeLinkedTest).sort(compareLinkedTests);
+}
+function normalizeTrimmedStringList(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    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 : undefined;
+}
+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 undefined;
+    }
+    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) : undefined;
+}
+function normalizeNumericRecord(value) {
+    if (!isPlainObjectRecord(value)) {
+        return undefined;
+    }
+    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) : undefined;
+}
+function normalizeLinkedTestContextMode(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || !LINKED_TEST_PM_CONTEXT_MODE_VALUES.has(normalized)) {
+        return undefined;
+    }
+    return normalized;
+}
+function normalizeLinkedTest(value) {
+    const test = {
         command: value.command?.trim() || undefined,
         path: value.path ? normalizePathValue(value.path) : undefined,
         scope: value.scope,
         timeout_seconds: typeof value.timeout_seconds === "number" && Number.isFinite(value.timeout_seconds) && value.timeout_seconds > 0
             ? value.timeout_seconds
             : undefined,
-        pm_context_mode: (() => {
-            const normalized = value.pm_context_mode?.trim().toLowerCase();
-            if (!normalized || !LINKED_TEST_PM_CONTEXT_MODE_VALUES.has(normalized)) {
-                return undefined;
-            }
-            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)))
-            : undefined,
-        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))
-            : undefined,
+        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 : undefined,
-        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))
-            : undefined,
-        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))
-            : undefined,
-        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))
-            : undefined,
-        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))
-            : undefined,
-        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)
-            : undefined,
-        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)))
-            : undefined,
-        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)))
-            : undefined,
+        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() || undefined,
-    }))
-        .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)
@@ -661,65 +747,75 @@ function normalizePlanStepDocs(value) {
     }
     return out.length > 0 ? out : undefined;
 }
+function normalizePlanStepEntry(entry) {
+    if (entry === null || typeof entry !== "object") {
+        return undefined;
+    }
+    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 : undefined;
+    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 undefined;
+    }
+    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 : undefined;
+    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 undefined;
-    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: 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 : undefined;
-        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 : undefined;
 }
@@ -842,6 +938,48 @@ function normalizeSeverityValue(value) {
     }
     return undefined;
 }
+function emptyStringToUndefined(value) {
+    return value || undefined;
+}
+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 === undefined) {
+            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 === undefined) {
+            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(",")}`);
+    }
+}
 /**
  * Implements normalize front matter for the public runtime surface of this module.
  */
@@ -855,7 +993,7 @@ export function normalizeFrontMatter(frontMatter, options = {}) {
         description: frontMatter.description,
         type: frontMatter.type,
         pm_format_version: normalizeItemFormatVersion(frontMatter.pm_format_version),
-        source_type: frontMatter.source_type?.trim() || undefined,
+        source_type: trimStringOrUndefined(frontMatter.source_type),
         type_options: normalizeTypeOptions(frontMatter.type_options),
         status: normalizedStatus,
         priority: frontMatter.priority,
@@ -870,47 +1008,47 @@ export function normalizeFrontMatter(frontMatter, options = {}) {
         tests: sortTests(frontMatter.tests),
         test_runs: normalizeTestRunSummaries(frontMatter.test_runs),
         docs: sortDocs(frontMatter.docs),
-        deadline: frontMatter.deadline || undefined,
+        deadline: emptyStringToUndefined(frontMatter.deadline),
         reminders: sortReminders(frontMatter.reminders),
         events: sortEvents(frontMatter.events),
-        closed_at: frontMatter.closed_at || undefined,
-        assignee: frontMatter.assignee?.trim() || undefined,
-        source_owner: frontMatter.source_owner?.trim() || undefined,
-        author: frontMatter.author || undefined,
+        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 ?? undefined,
         design: frontMatter.design ?? undefined,
         external_ref: frontMatter.external_ref ?? undefined,
-        definition_of_ready: frontMatter.definition_of_ready?.trim() || undefined,
+        definition_of_ready: trimStringOrUndefined(frontMatter.definition_of_ready),
         order: frontMatter.order,
-        goal: frontMatter.goal?.trim() || undefined,
-        objective: frontMatter.objective?.trim() || undefined,
-        value: frontMatter.value?.trim() || undefined,
-        impact: frontMatter.impact?.trim() || undefined,
-        outcome: frontMatter.outcome?.trim() || undefined,
-        why_now: frontMatter.why_now?.trim() || undefined,
-        parent: frontMatter.parent?.trim() || undefined,
-        reviewer: frontMatter.reviewer?.trim() || undefined,
+        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 ?? undefined,
         confidence: normalizeConfidenceValue(frontMatter.confidence),
-        sprint: frontMatter.sprint?.trim() || undefined,
-        release: frontMatter.release?.trim() || undefined,
-        blocked_by: frontMatter.blocked_by?.trim() || undefined,
-        blocked_reason: frontMatter.blocked_reason?.trim() || undefined,
-        unblock_note: frontMatter.unblock_note?.trim() || undefined,
-        reporter: frontMatter.reporter?.trim() || undefined,
+        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() || undefined,
-        repro_steps: frontMatter.repro_steps?.trim() || undefined,
-        resolution: frontMatter.resolution?.trim() || undefined,
-        expected_result: frontMatter.expected_result?.trim() || undefined,
-        actual_result: frontMatter.actual_result?.trim() || undefined,
-        affected_version: frontMatter.affected_version?.trim() || undefined,
-        fixed_version: frontMatter.fixed_version?.trim() || undefined,
-        component: frontMatter.component?.trim() || undefined,
+        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() || undefined,
-        close_reason: frontMatter.close_reason || undefined,
+        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),
@@ -920,38 +1058,10 @@ export 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 === undefined) {
-            continue;
-        }
-        normalized[key] = value;
-    }
-    if (runtimeContext?.fieldRegistry) {
-        for (const definition of runtimeContext.fieldRegistry.definitions) {
-            const currentValue = normalized[definition.metadata_key];
-            if (currentValue === undefined) {
-                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 === undefined) {
-            delete normalized[key];
-        }
-    }
+    copyExtensionFrontMatterFields(normalized, frontMatter);
+    coerceNormalizedRuntimeFields(normalized, runtimeContext);
+    assertNormalizedUnknownFields(normalized, runtimeContext);
+    deleteUndefinedFields(normalized);
     return normalized;
 }
 function orderFrontMatter(frontMatter) {
@@ -1028,6 +1138,9 @@ function stripLeadingYamlDocument(content) {
     }
     return { content: normalizedContent, stripped: false };
 }
+function normalizeParsedFrontMatter(frontMatter, options) {
+    return normalizeFrontMatter(frontMatter, { ...options, onWarning: undefined });
+}
 function parseJsonMarkdownItemDocument(content, runtimeContext, options = {}) {
     const normalized = stripLeadingYamlDocument(content);
     if (normalized.stripped) {
@@ -1050,7 +1163,7 @@ function parseJsonMarkdownItemDocument(content, runtimeContext, options = {}) {
     }
     assertValidFrontMatter(parsed, runtimeContext);
     return {
-        metadata: normalizeFrontMatter(parsed, options),
+        metadata: normalizeParsedFrontMatter(parsed, options),
         body: normalizeBody(body),
     };
 }
@@ -1073,7 +1186,7 @@ function parseToonItemDocument(content, runtimeContext, options = {}) {
         assertValidFrontMatter(record.front_matter, runtimeContext);
         assertFrontMatterCondition(record.body === undefined || 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 : ""),
         };
     }
@@ -1081,7 +1194,7 @@ function parseToonItemDocument(content, runtimeContext, options = {}) {
     assertFrontMatterCondition(body === undefined || 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 : ""),
     };
 }
@@ -1155,4 +1268,4 @@ export const _testOnlyItemFormat = {
     sortTests,
 };
 //# sourceMappingURL=item-format.js.map
-//# debugId=777ea2a9-5aa6-5a90-abb5-a0b6052645f2
+//# debugId=84d024fa-403c-5a85-8c12-4e823afa4fc9