@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli-bundle/chunks/chunk-KBG47ZOY.js

@@ -0,0 +1,1325 @@
+
+!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]="b9b7439e-7986-5a85-9356-8d54578b038a")}catch(e){}}();
+import {
+  compareTimestampStrings,
+  isTimestampLiteral
+} from "./chunk-NQP3ECKF.js";
+import {
+  CONFIDENCE_TEXT_VALUES,
+  EXIT_CODE,
+  FRONT_MATTER_KEY_ORDER,
+  ISSUE_SEVERITY_VALUES,
+  PmCliError,
+  RECURRENCE_FREQUENCY_VALUES,
+  RECURRENCE_WEEKDAY_VALUES,
+  STATUS_VALUES,
+  normalizeStatusInputWithRegistry,
+  orderObject,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  runtimeFieldOptionTarget,
+  weekdayOrderIndex
+} from "./chunk-4LTBNUYT.js";
+
+// dist/core/schema/runtime-field-values.js
+function toCamelToken(value) {
+  const segments = value.trim().replaceAll(/[^A-Za-z0-9]+/g, " ").split(/\s+/).filter((segment) => segment.length > 0).map((segment) => segment.toLowerCase());
+  if (segments.length === 0) {
+    return value;
+  }
+  const [first, ...rest] = segments;
+  return `${first}${rest.map((segment) => `${segment.slice(0, 1).toUpperCase()}${segment.slice(1)}`).join("")}`;
+}
+function resolveCandidateOptionKeys(definition) {
+  return [.../* @__PURE__ */ new Set([
+    runtimeFieldOptionTarget(definition),
+    toCamelToken(definition.key),
+    toCamelToken(definition.cli_flag),
+    ...definition.cli_aliases.map((alias) => toCamelToken(alias))
+  ])];
+}
+function readRuntimeFieldOptionValue(options, definition) {
+  for (const candidateKey of resolveCandidateOptionKeys(definition)) {
+    if (!Object.hasOwn(options, candidateKey)) {
+      continue;
+    }
+    const value = options[candidateKey];
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function normalizeStringArrayValue(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => normalizeStringArrayValue(entry)).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  }
+  if (typeof value === "string") {
+    return value.split(/[,\n|]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  }
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  return [String(value).trim()].filter((entry) => entry.length > 0);
+}
+function parseBooleanValue(raw, label) {
+  if (typeof raw === "boolean") {
+    return raw;
+  }
+  if (typeof raw === "number") {
+    if (raw === 1) {
+      return true;
+    }
+    if (raw === 0) {
+      return false;
+    }
+  }
+  if (typeof raw === "string") {
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no") {
+      return false;
+    }
+  }
+  throw new PmCliError(`${label} must be one of true|false|1|0|yes|no`, EXIT_CODE.USAGE);
+}
+function parseNumberValue(raw, label) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw;
+  }
+  const candidate = typeof raw === "string" ? raw.trim() : String(raw);
+  const parsed = Number(candidate);
+  if (!Number.isFinite(parsed)) {
+    throw new PmCliError(`${label} must be a number`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function coerceRuntimeFieldValue(definition, rawValue, labelOverride) {
+  const label = labelOverride ?? `--${definition.cli_flag}`;
+  if (definition.repeatable || definition.type === "string_array") {
+    const values = normalizeStringArrayValue(rawValue);
+    if (definition.type === "number") {
+      return values.map((value) => parseNumberValue(value, label));
+    }
+    if (definition.type === "boolean") {
+      return values.map((value) => parseBooleanValue(value, label));
+    }
+    return values;
+  }
+  const scalarRaw = Array.isArray(rawValue) ? rawValue[rawValue.length - 1] : rawValue;
+  if (scalarRaw === void 0) {
+    return void 0;
+  }
+  if (definition.type === "number") {
+    return parseNumberValue(scalarRaw, label);
+  }
+  if (definition.type === "boolean") {
+    return parseBooleanValue(scalarRaw, label);
+  }
+  return typeof scalarRaw === "string" ? scalarRaw : String(scalarRaw);
+}
+function shouldRequireFieldOnCreate(definition, itemTypeName) {
+  if (!definition.required && !definition.required_on_create) {
+    return false;
+  }
+  if (definition.required_types.length === 0) {
+    return true;
+  }
+  if (!itemTypeName) {
+    return false;
+  }
+  return definition.required_types.map((value) => value.toLowerCase()).includes(itemTypeName.trim().toLowerCase());
+}
+function collectRuntimeCreateFieldValues(options, fieldRegistry, itemTypeName) {
+  const values = {};
+  const missingRequiredFlags = [];
+  for (const definition of fieldRegistry.command_to_fields.get("create") ?? []) {
+    const rawValue = readRuntimeFieldOptionValue(options, definition);
+    if (rawValue === void 0) {
+      if (shouldRequireFieldOnCreate(definition, itemTypeName)) {
+        missingRequiredFlags.push(`--${definition.cli_flag}`);
+      }
+      continue;
+    }
+    values[definition.metadata_key] = coerceRuntimeFieldValue(definition, rawValue);
+  }
+  return {
+    values,
+    missing_required_flags: [...new Set(missingRequiredFlags)].sort((left, right) => left.localeCompare(right))
+  };
+}
+function collectRuntimeUpdateFieldValues(options, fieldRegistry, commands = ["update"]) {
+  const values = {};
+  const definitions = (commands ?? ["update"]).flatMap((command) => fieldRegistry.command_to_fields.get(command) ?? []);
+  const seen = /* @__PURE__ */ new Set();
+  for (const definition of definitions) {
+    const rawValue = readRuntimeFieldOptionValue(options, definition);
+    if (rawValue === void 0) {
+      continue;
+    }
+    if (seen.has(definition.metadata_key)) {
+      continue;
+    }
+    seen.add(definition.metadata_key);
+    values[definition.metadata_key] = coerceRuntimeFieldValue(definition, rawValue);
+  }
+  return values;
+}
+
+// dist/core/item/status.js
+var STATUS_ALIAS_MAP = {
+  "in-progress": "in_progress",
+  cancelled: "canceled"
+};
+function normalizeStatusInput(value, registry) {
+  if (registry) {
+    const normalizedFromRegistry = normalizeStatusInputWithRegistry(value, registry);
+    if (normalizedFromRegistry) {
+      return normalizedFromRegistry;
+    }
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
+  }
+  const canonical = STATUS_ALIAS_MAP[normalized] ?? normalized;
+  if (!STATUS_VALUES.includes(canonical)) {
+    return void 0;
+  }
+  return canonical;
+}
+function normalizeStatusForRegistry(status, registry) {
+  return normalizeStatusInput(status, registry) ?? status;
+}
+function isTerminalStatus(status, registry) {
+  return registry.terminal_statuses.has(normalizeStatusForRegistry(status, registry));
+}
+
+// dist/core/shared/conflict-markers.js
+var CONFLICT_MARKER_PATTERN = /^\s*(<<<<<<<|=======|>>>>>>>)(?:\s.*)?$/;
+function findMergeConflictMarkers(content) {
+  if (content.length === 0) {
+    return [];
+  }
+  const lines = content.split(/\r?\n/);
+  const matches = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const markerMatch = line.match(CONFLICT_MARKER_PATTERN);
+    if (!markerMatch) {
+      continue;
+    }
+    const marker = markerMatch[1];
+    matches.push({
+      line: index + 1,
+      marker,
+      text: line
+    });
+  }
+  return matches;
+}
+function findFirstMergeConflictMarker(content) {
+  const matches = findMergeConflictMarkers(content);
+  return matches[0];
+}
+
+// dist/core/item/item-format.js
+import { encode as encodeToon } from "@toon-format/toon";
+
+// dist/core/item/toon-decode.js
+import { decode as decodeToon } from "@toon-format/toon";
+function escapeBracketsInQuotedScalars(content) {
+  return content.split("\n").map((line) => {
+    const separatorIndex = line.indexOf(": ");
+    const bracketIndex = line.indexOf("[");
+    if (separatorIndex === -1 || bracketIndex === -1 || bracketIndex < separatorIndex) {
+      return line;
+    }
+    const key = line.slice(0, separatorIndex + 2);
+    const value = line.slice(separatorIndex + 2);
+    if (!value.startsWith('"')) {
+      return line;
+    }
+    return key + value.replaceAll("[", "\\u005b");
+  }).join("\n");
+}
+function decodeToonItemContent(content) {
+  try {
+    return { value: decodeToon(content), usedScalarBracketEscape: false };
+  } catch (strictError) {
+    const escaped = escapeBracketsInQuotedScalars(content);
+    if (escaped === content) {
+      throw strictError;
+    }
+    return { value: decodeToon(escaped), usedScalarBracketEscape: true };
+  }
+}
+
+// dist/core/item/item-format.js
+var LINKED_TEST_PM_CONTEXT_MODE_VALUES = /* @__PURE__ */ new Set(["schema", "tracker", "auto"]);
+function normalizePathValue(value) {
+  return value.replaceAll("\\", "/");
+}
+var REQUIRED_STRING_FIELDS = [
+  "id",
+  "title",
+  "description",
+  "created_at",
+  "updated_at"
+];
+var STATIC_FRONT_MATTER_FIELD_SET = new Set(FRONT_MATTER_KEY_ORDER);
+function resolveRuntimeSchemaValidationContext(options) {
+  if (!options?.schema) {
+    return void 0;
+  }
+  return {
+    statusRegistry: resolveRuntimeStatusRegistry(options.schema),
+    fieldRegistry: resolveRuntimeFieldRegistry(options.schema),
+    unknownFieldPolicy: options.schema.unknown_field_policy ?? "allow",
+    extensionFieldNames: new Set(options.extensionFieldNames ?? []),
+    onWarning: options.onWarning
+  };
+}
+function runtimeFieldRequiredForType(definition, typeName) {
+  if (!definition.required) {
+    return false;
+  }
+  if (definition.required_types.length === 0) {
+    return true;
+  }
+  return definition.required_types.map((value) => value.toLowerCase()).includes(typeName.trim().toLowerCase());
+}
+function validationError(message) {
+  throw new PmCliError(`Invalid item front matter: ${message}`, EXIT_CODE.GENERIC_FAILURE);
+}
+function buildKnownFrontMatterKeys(runtimeContext) {
+  const knownKeys = new Set(STATIC_FRONT_MATTER_FIELD_SET);
+  for (const definition of runtimeContext.fieldRegistry?.definitions ?? []) {
+    knownKeys.add(definition.metadata_key);
+  }
+  for (const fieldName of runtimeContext.extensionFieldNames) {
+    knownKeys.add(fieldName);
+  }
+  return knownKeys;
+}
+function assertFrontMatterCondition(condition, message) {
+  if (!condition) {
+    validationError(message);
+  }
+}
+function assertTimestampField(record, fieldName) {
+  const rawValue = record[fieldName];
+  assertFrontMatterCondition(typeof rawValue === "string", `${fieldName} must be a string`);
+  const timestamp = rawValue;
+  assertFrontMatterCondition(isTimestampLiteral(timestamp), `${fieldName} must be a valid ISO timestamp`);
+}
+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;
+  for (const fieldName of REQUIRED_STRING_FIELDS) {
+    assertFrontMatterCondition(typeof record[fieldName] === "string", `${fieldName} is required and must be a string`);
+  }
+  const itemType = record.type;
+  assertFrontMatterCondition(typeof itemType === "string" && itemType.trim().length > 0, "type must be a non-empty string");
+  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(", ")}`);
+  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;
+  assertFrontMatterCondition(Array.isArray(tags), "tags must be an array");
+  for (const tag of tags) {
+    assertFrontMatterCondition(typeof tag === "string", "tags entries must be strings");
+  }
+  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");
+    }
+  }
+  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");
+    }
+  }
+  assertTimestampField(record, "created_at");
+  assertTimestampField(record, "updated_at");
+  if (record.deadline !== void 0) {
+    assertTimestampField(record, "deadline");
+  }
+  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");
+    }
+  }
+  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");
+        }
+      }
+    }
+  }
+  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");
+  }
+  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`);
+    }
+  }
+  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 (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(error instanceof Error ? error.message.replace(/^Invalid\s+/u, "") : `invalid ${definition.metadata_key} value`);
+      }
+    }
+  }
+  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 sortDependencies(values) {
+  if (!values || values.length === 0)
+    return void 0;
+  return [...values].map((value) => ({
+    id: value.id.trim().toLowerCase(),
+    kind: value.kind,
+    created_at: value.created_at,
+    author: value.author?.trim() || void 0,
+    source_kind: value.source_kind?.trim() || void 0
+  })).sort((a, b) => {
+    const byCreated = compareTimestampStrings(a.created_at, b.created_at);
+    if (byCreated !== 0)
+      return byCreated;
+    const byId = a.id.localeCompare(b.id);
+    if (byId !== 0)
+      return byId;
+    const byKind = a.kind.localeCompare(b.kind);
+    if (byKind !== 0)
+      return byKind;
+    return (a.source_kind ?? "").localeCompare(b.source_kind ?? "");
+  });
+}
+function sortLogValues(values) {
+  if (!values || values.length === 0)
+    return void 0;
+  return [...values].sort((a, b) => {
+    const byCreated = compareTimestampStrings(a.created_at, b.created_at);
+    if (byCreated !== 0)
+      return byCreated;
+    const byText = a.text.localeCompare(b.text);
+    if (byText !== 0)
+      return byText;
+    return a.author.localeCompare(b.author);
+  });
+}
+function sortReminders(values) {
+  if (!values || values.length === 0)
+    return void 0;
+  const normalized = [...values].map((value) => ({
+    at: value.at,
+    text: value.text.trim()
+  })).filter((value) => value.text.length > 0).sort((a, b) => {
+    const byAt = compareTimestampStrings(a.at, b.at);
+    if (byAt !== 0)
+      return byAt;
+    return a.text.localeCompare(b.text);
+  });
+  return normalized.length === 0 ? void 0 : normalized;
+}
+function normalizeRecurrenceRule(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalizedFrequency = value.freq.trim().toLowerCase();
+  if (!RECURRENCE_FREQUENCY_VALUES.includes(normalizedFrequency)) {
+    return void 0;
+  }
+  const byWeekday = Array.from(new Set((value.by_weekday ?? []).map((weekday) => weekday.trim().toLowerCase()).filter((weekday) => RECURRENCE_WEEKDAY_VALUES.includes(weekday)))).sort((a, b) => weekdayOrderIndex(a) - weekdayOrderIndex(b));
+  const byMonthDay = Array.from(new Set((value.by_month_day ?? []).filter((day) => Number.isInteger(day) && day >= 1 && day <= 31).map((day) => day))).sort((a, b) => a - b);
+  const exdates = Array.from(new Set((value.exdates ?? []).map((timestamp) => timestamp.trim()).filter((timestamp) => isTimestampLiteral(timestamp)))).sort((a, b) => compareTimestampStrings(a, b));
+  const normalized = {
+    freq: normalizedFrequency,
+    interval: value.interval !== void 0 && value.interval > 1 ? value.interval : void 0,
+    count: value.count,
+    until: value.until?.trim() || void 0,
+    by_weekday: byWeekday.length > 0 ? byWeekday : void 0,
+    by_month_day: byMonthDay.length > 0 ? byMonthDay : void 0,
+    exdates: exdates.length > 0 ? exdates : void 0
+  };
+  for (const [key, fieldValue] of Object.entries(normalized)) {
+    if (fieldValue === void 0) {
+      delete normalized[key];
+    }
+  }
+  return normalized;
+}
+function sortEvents(values) {
+  if (!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 ?? {}));
+  });
+  return normalized;
+}
+function normalizeFiles(values) {
+  if (!values || values.length === 0)
+    return void 0;
+  return values.map((value) => ({
+    path: normalizePathValue(value.path),
+    scope: value.scope,
+    note: value.note?.trim() || void 0
+  }));
+}
+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) => {
+    const byRecorded = compareTimestampStrings(a.recorded_at, b.recorded_at);
+    if (byRecorded !== 0)
+      return byRecorded;
+    const byRunId = a.run_id.localeCompare(b.run_id);
+    if (byRunId !== 0)
+      return byRunId;
+    return a.kind.localeCompare(b.kind);
+  });
+  return normalized.length > 0 ? normalized : void 0;
+}
+function sortTests(values) {
+  if (!values || values.length === 0)
+    return void 0;
+  return [...values].map((value) => ({
+    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,
+    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,
+    note: value.note?.trim() || void 0
+  })).sort((a, b) => {
+    const byScope = a.scope.localeCompare(b.scope);
+    if (byScope !== 0)
+      return byScope;
+    const byPath = (a.path ?? "").localeCompare(b.path ?? "");
+    if (byPath !== 0)
+      return byPath;
+    const byCommand = (a.command ?? "").localeCompare(b.command ?? "");
+    if (byCommand !== 0)
+      return byCommand;
+    const byTimeout = (a.timeout_seconds ?? 0) - (b.timeout_seconds ?? 0);
+    if (byTimeout !== 0)
+      return byTimeout;
+    const byPmContext = (a.pm_context_mode ?? "").localeCompare(b.pm_context_mode ?? "");
+    if (byPmContext !== 0)
+      return byPmContext;
+    const bySharedHostSafe = Number(Boolean(a.shared_host_safe)) - Number(Boolean(b.shared_host_safe));
+    if (bySharedHostSafe !== 0)
+      return bySharedHostSafe;
+    const byEnvClear = JSON.stringify(a.env_clear ?? []).localeCompare(JSON.stringify(b.env_clear ?? []));
+    if (byEnvClear !== 0)
+      return byEnvClear;
+    const byEnvSet = JSON.stringify(a.env_set ?? {}).localeCompare(JSON.stringify(b.env_set ?? {}));
+    if (byEnvSet !== 0)
+      return byEnvSet;
+    const byStdoutContains = JSON.stringify(a.assert_stdout_contains ?? []).localeCompare(JSON.stringify(b.assert_stdout_contains ?? []));
+    if (byStdoutContains !== 0)
+      return byStdoutContains;
+    const byStdoutRegex = JSON.stringify(a.assert_stdout_regex ?? []).localeCompare(JSON.stringify(b.assert_stdout_regex ?? []));
+    if (byStdoutRegex !== 0)
+      return byStdoutRegex;
+    const byStderrContains = JSON.stringify(a.assert_stderr_contains ?? []).localeCompare(JSON.stringify(b.assert_stderr_contains ?? []));
+    if (byStderrContains !== 0)
+      return byStderrContains;
+    const byStderrRegex = JSON.stringify(a.assert_stderr_regex ?? []).localeCompare(JSON.stringify(b.assert_stderr_regex ?? []));
+    if (byStderrRegex !== 0)
+      return byStderrRegex;
+    const byStdoutMinLines = (a.assert_stdout_min_lines ?? 0) - (b.assert_stdout_min_lines ?? 0);
+    if (byStdoutMinLines !== 0)
+      return byStdoutMinLines;
+    const byJsonFieldEquals = JSON.stringify(a.assert_json_field_equals ?? {}).localeCompare(JSON.stringify(b.assert_json_field_equals ?? {}));
+    if (byJsonFieldEquals !== 0)
+      return byJsonFieldEquals;
+    const byJsonFieldGte = JSON.stringify(a.assert_json_field_gte ?? {}).localeCompare(JSON.stringify(b.assert_json_field_gte ?? {}));
+    if (byJsonFieldGte !== 0)
+      return byJsonFieldGte;
+    return (a.note ?? "").localeCompare(b.note ?? "");
+  });
+}
+function sortDocs(values) {
+  if (!values || values.length === 0)
+    return void 0;
+  return [...values].map((value) => ({
+    path: normalizePathValue(value.path),
+    scope: value.scope,
+    note: value.note?.trim() || void 0
+  })).sort((a, b) => {
+    const byScope = a.scope.localeCompare(b.scope);
+    if (byScope !== 0)
+      return byScope;
+    const byPath = a.path.localeCompare(b.path);
+    if (byPath !== 0)
+      return byPath;
+    return (a.note ?? "").localeCompare(b.note ?? "");
+  });
+}
+function trimStringOrUndefined(value) {
+  if (typeof value !== "string")
+    return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizePlanStepLinks(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 kind = trimStringOrUndefined(record.kind);
+    if (!id || !kind)
+      continue;
+    const link = { id, kind };
+    const note = trimStringOrUndefined(record.note);
+    if (note)
+      link.note = note;
+    if (record.required_before_step === true)
+      link.required_before_step = true;
+    out.push(link);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizePlanStepFiles(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 path = trimStringOrUndefined(record.path);
+    if (!path)
+      continue;
+    const file = { path: normalizePathValue(path) };
+    if (record.scope === "project" || record.scope === "global")
+      file.scope = record.scope;
+    const note = trimStringOrUndefined(record.note);
+    if (note)
+      file.note = note;
+    out.push(file);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizePlanStepTests(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 command = trimStringOrUndefined(record.command);
+    const path = trimStringOrUndefined(record.path);
+    if (!command && !path)
+      continue;
+    const test = {};
+    if (command)
+      test.command = command;
+    if (path)
+      test.path = normalizePathValue(path);
+    const note = trimStringOrUndefined(record.note);
+    if (note)
+      test.note = note;
+    out.push(test);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizePlanStepDocs(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 path = trimStringOrUndefined(record.path);
+    if (!path)
+      continue;
+    const doc = { path: normalizePathValue(path) };
+    if (record.scope === "project" || record.scope === "global")
+      doc.scope = record.scope;
+    const note = trimStringOrUndefined(record.note);
+    if (note)
+      doc.note = note;
+    out.push(doc);
+  }
+  return out.length > 0 ? out : void 0;
+}
+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);
+  }
+  out.sort((left, right) => left.order - right.order);
+  return out.length > 0 ? out : void 0;
+}
+function normalizePlanDecisions(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 ts = typeof record.ts === "string" ? record.ts : "";
+    const author = typeof record.author === "string" ? record.author : "";
+    const decision = trimStringOrUndefined(record.decision);
+    if (!ts || !author || !decision)
+      continue;
+    const item = { ts, author, decision };
+    const rationale = trimStringOrUndefined(record.rationale);
+    if (rationale)
+      item.rationale = rationale;
+    const evidence = trimStringOrUndefined(record.evidence);
+    if (evidence)
+      item.evidence = evidence;
+    const stepId = trimStringOrUndefined(record.step_id);
+    if (stepId)
+      item.step_id = stepId;
+    out.push(item);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizePlanDiscoveries(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 ts = typeof record.ts === "string" ? record.ts : "";
+    const author = typeof record.author === "string" ? record.author : "";
+    const text = trimStringOrUndefined(record.text);
+    if (!ts || !author || !text)
+      continue;
+    const item = { ts, author, text };
+    const stepId = trimStringOrUndefined(record.step_id);
+    if (stepId)
+      item.step_id = stepId;
+    out.push(item);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizePlanValidation(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 text = trimStringOrUndefined(record.text);
+    if (!text)
+      continue;
+    const item = { text };
+    const command = trimStringOrUndefined(record.command);
+    if (command)
+      item.command = command;
+    const expected = trimStringOrUndefined(record.expected);
+    if (expected)
+      item.expected = expected;
+    out.push(item);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function normalizeTypeOptions(values) {
+  if (!values) {
+    return void 0;
+  }
+  const normalizedEntries = Object.entries(values).map(([key, value]) => [key.trim(), value.trim()]).filter(([key, value]) => key.length > 0 && value.length > 0).sort((left, right) => left[0].localeCompare(right[0]));
+  if (normalizedEntries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(normalizedEntries);
+}
+function normalizeBody(body) {
+  return body.replace(/^\n+/, "").replace(/\s+$/, "");
+}
+function normalizeConfidenceValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "med") {
+    return "medium";
+  }
+  if (CONFIDENCE_TEXT_VALUES.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeSeverityValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "med") {
+    return "medium";
+  }
+  if (ISSUE_SEVERITY_VALUES.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeFrontMatter(frontMatter, options = {}) {
+  const runtimeContext = resolveRuntimeSchemaValidationContext(options);
+  const normalizedStatus = normalizeStatusInput(frontMatter.status, runtimeContext?.statusRegistry) ?? frontMatter.status;
+  const tags = Array.from(new Set(frontMatter.tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean))).sort((a, b) => a.localeCompare(b));
+  const normalized = {
+    id: frontMatter.id,
+    title: frontMatter.title,
+    description: frontMatter.description,
+    type: frontMatter.type,
+    source_type: frontMatter.source_type?.trim() || void 0,
+    type_options: normalizeTypeOptions(frontMatter.type_options),
+    status: normalizedStatus,
+    priority: frontMatter.priority,
+    tags,
+    created_at: frontMatter.created_at,
+    updated_at: frontMatter.updated_at,
+    dependencies: sortDependencies(frontMatter.dependencies),
+    comments: sortLogValues(frontMatter.comments),
+    notes: sortLogValues(frontMatter.notes),
+    learnings: sortLogValues(frontMatter.learnings),
+    files: normalizeFiles(frontMatter.files),
+    tests: sortTests(frontMatter.tests),
+    test_runs: normalizeTestRunSummaries(frontMatter.test_runs),
+    docs: sortDocs(frontMatter.docs),
+    deadline: frontMatter.deadline || void 0,
+    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,
+    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,
+    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,
+    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,
+    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,
+    regression: frontMatter.regression,
+    customer_impact: frontMatter.customer_impact?.trim() || void 0,
+    close_reason: frontMatter.close_reason || void 0,
+    plan_mode: trimStringOrUndefined(frontMatter.plan_mode),
+    plan_scope: trimStringOrUndefined(frontMatter.plan_scope),
+    plan_harness: trimStringOrUndefined(frontMatter.plan_harness),
+    plan_resume_context: trimStringOrUndefined(frontMatter.plan_resume_context),
+    plan_steps: normalizePlanSteps(frontMatter.plan_steps),
+    plan_decisions: normalizePlanDecisions(frontMatter.plan_decisions),
+    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];
+    }
+  }
+  return normalized;
+}
+function orderFrontMatter(frontMatter) {
+  return orderObject(frontMatter, FRONT_MATTER_KEY_ORDER);
+}
+function findJsonObjectEnd(content) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < content.length; i += 1) {
+    const char = content[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function splitFrontMatter(content) {
+  if (!content.startsWith("{")) {
+    return { frontMatter: "", body: content };
+  }
+  const end = findJsonObjectEnd(content);
+  if (end < 0) {
+    return { frontMatter: "", body: content };
+  }
+  const frontMatter = content.slice(0, end + 1);
+  const body = content.slice(end + 1).replace(/^\r?\n+/, "");
+  return { frontMatter, body };
+}
+function stripLeadingYamlDocument(content) {
+  const normalizedContent = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  const opener = normalizedContent.match(/^[ \t]*---[ \t]*(?:\r?\n|$)/);
+  if (!opener) {
+    return { content: normalizedContent, stripped: false };
+  }
+  let cursor = opener[0].length;
+  while (cursor < normalizedContent.length) {
+    const nextNewline = normalizedContent.indexOf("\n", cursor);
+    const lineEnd = nextNewline === -1 ? normalizedContent.length : nextNewline;
+    const line = normalizedContent.slice(cursor, lineEnd).replace(/\r$/, "");
+    const afterLine = nextNewline === -1 ? lineEnd : lineEnd + 1;
+    if (line.trim() === "---") {
+      return { content: normalizedContent.slice(afterLine).replace(/^\s+/, ""), stripped: true };
+    }
+    cursor = afterLine;
+  }
+  return { content: normalizedContent, stripped: false };
+}
+function parseJsonMarkdownItemDocument(content, runtimeContext, options = {}) {
+  const normalized = stripLeadingYamlDocument(content);
+  if (normalized.stripped) {
+    options.onWarning?.("json_markdown_leading_yaml_frontmatter_ignored");
+  }
+  const { frontMatter, body } = splitFrontMatter(normalized.content);
+  if (!frontMatter) {
+    const trimmed = content.trimStart();
+    if (trimmed.startsWith("{")) {
+      validationError("JSON front matter is not valid JSON");
+    }
+    validationError("missing JSON front matter");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(frontMatter);
+  } catch {
+    validationError("JSON front matter is not valid JSON");
+  }
+  assertValidFrontMatter(parsed, runtimeContext);
+  return {
+    metadata: normalizeFrontMatter(parsed, options),
+    body: normalizeBody(body)
+  };
+}
+function parseToonItemDocument(content, runtimeContext, options = {}) {
+  let parsed;
+  try {
+    parsed = decodeToonItemContent(content).value;
+  } catch {
+    validationError("TOON item document is not valid TOON");
+  }
+  assertFrontMatterCondition(typeof parsed === "object" && parsed !== null && !Array.isArray(parsed), "TOON item document must be an object");
+  const record = parsed;
+  if (Object.prototype.hasOwnProperty.call(record, "front_matter")) {
+    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),
+      body: normalizeBody(typeof record.body === "string" ? record.body : "")
+    };
+  }
+  const { body, ...frontMatterRecord } = record;
+  assertFrontMatterCondition(body === void 0 || typeof body === "string", "TOON item document body must be a string");
+  assertValidFrontMatter(frontMatterRecord, runtimeContext);
+  return {
+    metadata: normalizeFrontMatter(frontMatterRecord, options),
+    body: normalizeBody(typeof body === "string" ? body : "")
+  };
+}
+function serializeJsonMarkdownItemDocument(document, options = {}) {
+  const normalizedFrontMatter = normalizeFrontMatter(document.metadata, options);
+  const orderedFrontMatter = orderFrontMatter(normalizedFrontMatter);
+  const serializedFrontMatter = JSON.stringify(orderedFrontMatter, null, 2);
+  const normalizedBody = normalizeBody(document.body ?? "");
+  if (!normalizedBody) {
+    return `${serializedFrontMatter}
+`;
+  }
+  return `${serializedFrontMatter}
+
+${normalizedBody}
+`;
+}
+function serializeToonItemDocument(document, options = {}) {
+  const normalizedFrontMatter = normalizeFrontMatter(document.metadata, options);
+  const orderedFrontMatter = orderFrontMatter(normalizedFrontMatter);
+  const normalizedBody = normalizeBody(document.body ?? "");
+  return `${encodeToon({ ...orderedFrontMatter, body: normalizedBody })}
+`;
+}
+function parseItemDocument(content, options = {}) {
+  const conflictMarker = findFirstMergeConflictMarker(content);
+  if (conflictMarker) {
+    throw new PmCliError(`Merge conflict markers detected in item document at line ${conflictMarker.line} (${conflictMarker.marker}). Resolve <<<<<<< ======= >>>>>>> markers and retry.`, EXIT_CODE.GENERIC_FAILURE, {
+      code: "merge_conflict_markers_detected",
+      required: "Resolve merge-conflict markers in the item file before parsing or mutation commands.",
+      why: "Partially merged documents can corrupt item metadata and history integrity.",
+      examples: ["git status", "git add <resolved-file> && git commit"],
+      nextSteps: ["Resolve conflicts, save the file, then rerun the pm command."]
+    });
+  }
+  const format = options.format ?? "toon";
+  const runtimeContext = resolveRuntimeSchemaValidationContext(options);
+  return format === "toon" ? parseToonItemDocument(content, runtimeContext, options) : parseJsonMarkdownItemDocument(content, runtimeContext, options);
+}
+function serializeItemDocument(document, options = {}) {
+  const format = options.format ?? "toon";
+  return format === "toon" ? serializeToonItemDocument(document, options) : serializeJsonMarkdownItemDocument(document, options);
+}
+function canonicalDocument(document, options = {}) {
+  return {
+    metadata: normalizeFrontMatter(document.metadata, options),
+    body: normalizeBody(document.body ?? "")
+  };
+}
+
+export {
+  readRuntimeFieldOptionValue,
+  coerceRuntimeFieldValue,
+  collectRuntimeCreateFieldValues,
+  collectRuntimeUpdateFieldValues,
+  normalizeStatusInput,
+  normalizeStatusForRegistry,
+  isTerminalStatus,
+  findFirstMergeConflictMarker,
+  normalizeFrontMatter,
+  parseItemDocument,
+  serializeItemDocument,
+  canonicalDocument
+};
+//# sourceMappingURL=chunk-KBG47ZOY.js.map
+
+//# debugId=b9b7439e-7986-5a85-9356-8d54578b038a