@unbrained/pm-cli 2026.7.5 → 2026.7.6

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

@@ -1,1570 +0,0 @@
-
-!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]="4b8306b7-d6d7-5615-af29-66de3136cea2")}catch(e){}}();
-import {
-  compareTimestampStrings,
-  isTimestampLiteral
-} from "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  orderObject
-} from "./chunk-US3T3W5J.js";
-import {
-  CONFIDENCE_TEXT_VALUES,
-  EXIT_CODE,
-  FRONT_MATTER_KEY_ORDER,
-  ISSUE_SEVERITY_VALUES,
-  PLAN_STEP_STATUS_VALUES,
-  RECURRENCE_FREQUENCY_VALUES,
-  RECURRENCE_WEEKDAY_VALUES,
-  STATUS_VALUES,
-  TYPE_TO_FOLDER,
-  normalizeStatusInputWithRegistry,
-  pathExists,
-  resolveRuntimeFieldRegistry,
-  resolveRuntimeStatusRegistry,
-  runtimeFieldOptionTarget,
-  weekdayOrderIndex
-} from "./chunk-YD5FML7K.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/item-format-version.js
-var BASELINE_ITEM_FORMAT_VERSION = 1;
-var CURRENT_ITEM_FORMAT_VERSION = 1;
-function effectiveItemFormatVersion(metadata) {
-  const raw = metadata.pm_format_version;
-  if (typeof raw === "number" && Number.isInteger(raw) && raw >= BASELINE_ITEM_FORMAT_VERSION) {
-    return raw;
-  }
-  return BASELINE_ITEM_FORMAT_VERSION;
-}
-function normalizeItemFormatVersion(value) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= BASELINE_ITEM_FORMAT_VERSION) {
-    return void 0;
-  }
-  return value;
-}
-function classifyItemFormatVersion(version, current = CURRENT_ITEM_FORMAT_VERSION) {
-  if (version < current) {
-    return "outdated";
-  }
-  if (version > current) {
-    return "ahead";
-  }
-  return "current";
-}
-function scanItemFormatVersions(entries, current = CURRENT_ITEM_FORMAT_VERSION) {
-  const outdated = [];
-  const ahead = [];
-  for (const entry of entries) {
-    const status = classifyItemFormatVersion(entry.version, current);
-    if (status === "outdated") {
-      outdated.push(entry.ref);
-    } else if (status === "ahead") {
-      ahead.push(entry.ref);
-    }
-  }
-  return {
-    outdated: outdated.sort((left, right) => left.localeCompare(right)),
-    ahead: ahead.sort((left, right) => left.localeCompare(right))
-  };
-}
-
-// 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"]);
-var ITEM_TEST_RUN_STATUS_VALUES = /* @__PURE__ */ new Set(["passed", "failed", "stopped", "canceled"]);
-var PLAN_STEP_STATUS_SET = new Set(PLAN_STEP_STATUS_VALUES);
-function normalizePathValue(value) {
-  return value.replaceAll("\\", "/");
-}
-function firstNonZeroComparison(comparisons) {
-  for (const comparison of comparisons) {
-    if (comparison !== 0) {
-      return comparison;
-    }
-  }
-  return 0;
-}
-function deleteUndefinedFields(record) {
-  for (const [key, value] of Object.entries(record)) {
-    if (value === void 0) {
-      delete record[key];
-    }
-  }
-}
-var REQUIRED_STRING_FIELDS = [
-  "id",
-  "title",
-  "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 assertPositiveIntegerField(record, fieldName, messagePrefix) {
-  const value = record[fieldName];
-  if (value === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(typeof value === "number" && Number.isInteger(value) && value >= 1, `${messagePrefix} must be an integer >= 1`);
-}
-function assertOptionalTimestampString(record, fieldName, messagePrefix) {
-  const value = record[fieldName];
-  if (value === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(typeof value === "string", `${messagePrefix} must be a string`);
-  assertFrontMatterCondition(isTimestampLiteral(value), `${messagePrefix} must be a valid ISO timestamp`);
-}
-function assertRecurrenceWeekdays(value) {
-  if (value === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(Array.isArray(value), "event.recurrence.by_weekday must be an array");
-  for (const weekday of value) {
-    assertFrontMatterCondition(typeof weekday === "string", "event.recurrence.by_weekday entries must be strings");
-    const normalizedWeekday = weekday.trim().toLowerCase();
-    assertFrontMatterCondition(RECURRENCE_WEEKDAY_VALUES.includes(normalizedWeekday), `event.recurrence.by_weekday entries must be one of: ${RECURRENCE_WEEKDAY_VALUES.join(", ")}`);
-  }
-}
-function assertRecurrenceMonthDays(value) {
-  if (value === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(Array.isArray(value), "event.recurrence.by_month_day must be an array");
-  for (const day of value) {
-    assertFrontMatterCondition(typeof day === "number" && Number.isInteger(day) && day >= 1 && day <= 31, "event.recurrence.by_month_day entries must be integers 1..31");
-  }
-}
-function assertRecurrenceExdates(value) {
-  if (value === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(Array.isArray(value), "event.recurrence.exdates must be an array");
-  for (const exdate of value) {
-    assertFrontMatterCondition(typeof exdate === "string", "event.recurrence.exdates entries must be strings");
-    assertFrontMatterCondition(isTimestampLiteral(exdate), "event.recurrence.exdates entries must be valid ISO timestamps");
-  }
-}
-function assertValidRecurrenceRule(recurrence) {
-  assertFrontMatterCondition(typeof recurrence === "object" && recurrence !== null && !Array.isArray(recurrence), "event.recurrence must be an object");
-  const recurrenceRecord = recurrence;
-  assertFrontMatterCondition(typeof recurrenceRecord.freq === "string", "event.recurrence.freq must be a string");
-  const frequency = recurrenceRecord.freq.trim().toLowerCase();
-  assertFrontMatterCondition(RECURRENCE_FREQUENCY_VALUES.includes(frequency), `event.recurrence.freq must be one of: ${RECURRENCE_FREQUENCY_VALUES.join(", ")}`);
-  assertPositiveIntegerField(recurrenceRecord, "interval", "event.recurrence.interval");
-  assertPositiveIntegerField(recurrenceRecord, "count", "event.recurrence.count");
-  assertOptionalTimestampString(recurrenceRecord, "until", "event.recurrence.until");
-  assertRecurrenceWeekdays(recurrenceRecord.by_weekday);
-  assertRecurrenceMonthDays(recurrenceRecord.by_month_day);
-  assertRecurrenceExdates(recurrenceRecord.exdates);
-}
-function assertRequiredFrontMatterFields(record) {
-  for (const fieldName of REQUIRED_STRING_FIELDS) {
-    assertFrontMatterCondition(typeof record[fieldName] === "string", `${fieldName} is required and must be a string`);
-  }
-  const itemType = record.type;
-  assertFrontMatterCondition(typeof itemType === "string" && itemType.trim().length > 0, "type must be a non-empty string");
-  const formatVersion = record.pm_format_version;
-  if (formatVersion !== void 0) {
-    assertFrontMatterCondition(typeof formatVersion === "number" && Number.isInteger(formatVersion) && formatVersion >= BASELINE_ITEM_FORMAT_VERSION, `pm_format_version must be an integer >= ${BASELINE_ITEM_FORMAT_VERSION}`);
-  }
-  return itemType;
-}
-function assertStatusFrontMatterField(record, runtimeContext) {
-  const status = record.status;
-  assertFrontMatterCondition(typeof status === "string" && status.trim().length > 0, "status must be a non-empty string");
-  const statusRegistry = runtimeContext?.statusRegistry;
-  const normalizedStatus = normalizeStatusInput(status, statusRegistry);
-  const statusDomain = statusRegistry ? statusRegistry.definitions.map((definition) => definition.id) : [...STATUS_VALUES];
-  assertFrontMatterCondition(normalizedStatus !== void 0, `status must be one of: ${statusDomain.join(", ")}`);
-}
-function assertPriorityAndTags(record) {
-  const priority = record.priority;
-  assertFrontMatterCondition(typeof priority === "number" && Number.isInteger(priority) && [0, 1, 2, 3, 4].includes(priority), "priority must be an integer 0..4");
-  const tags = record.tags;
-  assertFrontMatterCondition(Array.isArray(tags), "tags must be an array");
-  for (const tag of tags) {
-    assertFrontMatterCondition(typeof tag === "string", "tags entries must be strings");
-  }
-}
-function assertConfidenceFrontMatterField(record) {
-  const confidence = record.confidence;
-  if (confidence === void 0) {
-    return;
-  }
-  if (typeof confidence === "number") {
-    assertFrontMatterCondition(Number.isInteger(confidence) && confidence >= 0 && confidence <= 100, "confidence number value must be an integer 0..100");
-    return;
-  }
-  if (typeof confidence === "string") {
-    const normalizedConfidence = confidence.trim().toLowerCase();
-    const isKnownTextConfidence = normalizedConfidence === "med" || CONFIDENCE_TEXT_VALUES.includes(normalizedConfidence);
-    assertFrontMatterCondition(isKnownTextConfidence, `confidence string value must be one of: ${[...CONFIDENCE_TEXT_VALUES, "med"].join(", ")}`);
-    return;
-  }
-  assertFrontMatterCondition(false, "confidence must be a number or string");
-}
-function assertSeverityFrontMatterField(record) {
-  const severity = record.severity;
-  if (severity === void 0) {
-    return;
-  }
-  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(", ")}`);
-}
-function assertRegressionFrontMatterField(record) {
-  if (record.regression !== void 0 && typeof record.regression !== "boolean") {
-    validationError("regression must be a boolean");
-  }
-}
-function assertReminderEntries(record) {
-  const reminders = record.reminders;
-  if (reminders === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(Array.isArray(reminders), "reminders must be an array");
-  for (const reminder of reminders) {
-    assertFrontMatterCondition(typeof reminder === "object" && reminder !== null && !Array.isArray(reminder), "reminders entries must be objects");
-    const reminderRecord = reminder;
-    assertFrontMatterCondition(typeof reminderRecord.at === "string", "reminder.at must be a string");
-    assertFrontMatterCondition(isTimestampLiteral(reminderRecord.at), "reminder.at must be a valid ISO timestamp");
-    assertFrontMatterCondition(typeof reminderRecord.text === "string", "reminder.text must be a string");
-    assertFrontMatterCondition(reminderRecord.text.trim().length > 0, "reminder.text must not be empty");
-  }
-}
-function assertEventStringFields(eventRecord) {
-  for (const stringField of ["title", "description", "location", "timezone"]) {
-    if (eventRecord[stringField] !== void 0) {
-      assertFrontMatterCondition(typeof eventRecord[stringField] === "string", `event.${stringField} must be a string`);
-      assertFrontMatterCondition(eventRecord[stringField].trim().length > 0, `event.${stringField} must not be empty`);
-    }
-  }
-}
-function assertEventRecurrence(eventRecord) {
-  if (eventRecord.recurrence === void 0) {
-    return;
-  }
-  assertValidRecurrenceRule(eventRecord.recurrence);
-  if (eventRecord.recurrence.until !== void 0) {
-    assertFrontMatterCondition(compareTimestampStrings(eventRecord.recurrence.until, eventRecord.start_at) >= 0, "event.recurrence.until must be at or after event.start_at");
-  }
-}
-function assertCalendarEventEntry(event) {
-  assertFrontMatterCondition(typeof event === "object" && event !== null && !Array.isArray(event), "events entries must be objects");
-  const eventRecord = event;
-  assertFrontMatterCondition(typeof eventRecord.start_at === "string", "event.start_at must be a string");
-  assertFrontMatterCondition(isTimestampLiteral(eventRecord.start_at), "event.start_at must be a valid ISO timestamp");
-  if (eventRecord.end_at !== void 0) {
-    assertFrontMatterCondition(typeof eventRecord.end_at === "string", "event.end_at must be a string");
-    assertFrontMatterCondition(isTimestampLiteral(eventRecord.end_at), "event.end_at must be a valid ISO timestamp");
-    assertFrontMatterCondition(compareTimestampStrings(eventRecord.end_at, eventRecord.start_at) > 0, "event.end_at must be after event.start_at");
-  }
-  assertEventStringFields(eventRecord);
-  if (eventRecord.all_day !== void 0) {
-    assertFrontMatterCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
-  }
-  assertEventRecurrence(eventRecord);
-}
-function assertCalendarEvents(record) {
-  const events = record.events;
-  if (events === void 0) {
-    return;
-  }
-  assertFrontMatterCondition(Array.isArray(events), "events must be an array");
-  for (const event of events) {
-    assertCalendarEventEntry(event);
-  }
-}
-function assertOptionalStringFields(record) {
-  for (const fieldName of ["source_type", "source_owner", "design", "external_ref"]) {
-    const value = record[fieldName];
-    if (value !== void 0) {
-      assertFrontMatterCondition(typeof value === "string", `${fieldName} must be a string`);
-    }
-  }
-}
-function assertTypeOptionsField(record) {
-  const typeOptions = record.type_options;
-  if (typeOptions === void 0) {
-    return;
-  }
-  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");
-  }
-}
-function coerceRuntimeFrontMatterFields(record, itemType, runtimeContext) {
-  if (!runtimeContext?.fieldRegistry) {
-    return;
-  }
-  for (const definition of runtimeContext.fieldRegistry.definitions) {
-    const fieldValue = record[definition.metadata_key];
-    if (fieldValue === void 0) {
-      if (runtimeFieldRequiredForType(definition, itemType)) {
-        validationError(`missing required schema field: ${definition.metadata_key}`);
-      }
-      continue;
-    }
-    try {
-      record[definition.metadata_key] = coerceRuntimeFieldValue(definition, fieldValue, `metadata field "${definition.metadata_key}"`);
-    } catch (error) {
-      validationError(String(error?.message).replace(/^Invalid\s+/u, ""));
-    }
-  }
-}
-function assertRuntimeUnknownFrontMatterFields(record, runtimeContext) {
-  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
-    return;
-  }
-  const knownKeys = buildKnownFrontMatterKeys(runtimeContext);
-  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key)).sort((left, right) => left.localeCompare(right));
-  if (unknownKeys.length === 0) {
-    return;
-  }
-  if (runtimeContext.unknownFieldPolicy === "reject") {
-    validationError(`unknown schema fields are not allowed: ${unknownKeys.join(", ")}`);
-  } else {
-    runtimeContext.onWarning?.(`item_unknown_schema_fields:${unknownKeys.join(",")}`);
-  }
-}
-function assertValidFrontMatter(frontMatter, runtimeContext) {
-  assertFrontMatterCondition(typeof frontMatter === "object" && frontMatter !== null && !Array.isArray(frontMatter), "front matter must be an object");
-  const record = frontMatter;
-  const itemType = assertRequiredFrontMatterFields(record);
-  assertStatusFrontMatterField(record, runtimeContext);
-  assertPriorityAndTags(record);
-  assertConfidenceFrontMatterField(record);
-  assertSeverityFrontMatterField(record);
-  assertRegressionFrontMatterField(record);
-  assertTimestampField(record, "created_at");
-  assertTimestampField(record, "updated_at");
-  if (record.deadline !== void 0) {
-    assertTimestampField(record, "deadline");
-  }
-  assertReminderEntries(record);
-  assertCalendarEvents(record);
-  assertOptionalTimestampString(record, "closed_at", "closed_at");
-  assertOptionalStringFields(record);
-  assertTypeOptionsField(record);
-  coerceRuntimeFrontMatterFields(record, itemType, runtimeContext);
-  assertRuntimeUnknownFrontMatterFields(record, runtimeContext);
-}
-function sortDependencies(values) {
-  if (!values || values.length === 0)
-    return void 0;
-  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 (!Array.isArray(values) || values.length === 0) {
-    return void 0;
-  }
-  const normalized = [...values].map(normalizeCalendarEvent).sort(compareCalendarEvents);
-  return normalized;
-}
-function normalizeCalendarEvent(value) {
-  const event = {
-    start_at: value.start_at,
-    end_at: value.end_at || void 0,
-    title: value.title?.trim() || void 0,
-    description: value.description?.trim() || void 0,
-    location: value.location?.trim() || void 0,
-    all_day: value.all_day,
-    timezone: value.timezone?.trim() || void 0,
-    recurrence: normalizeRecurrenceRule(value.recurrence)
-  };
-  deleteUndefinedFields(event);
-  return event;
-}
-function compareCalendarEvents(a, b) {
-  return firstNonZeroComparison([
-    compareTimestampStrings(a.start_at, b.start_at),
-    (a.end_at ?? "").localeCompare(b.end_at ?? ""),
-    (a.title ?? "").localeCompare(b.title ?? ""),
-    Number(Boolean(a.all_day)) - Number(Boolean(b.all_day)),
-    (a.timezone ?? "").localeCompare(b.timezone ?? ""),
-    (a.location ?? "").localeCompare(b.location ?? ""),
-    (a.description ?? "").localeCompare(b.description ?? ""),
-    JSON.stringify(a.recurrence ?? {}).localeCompare(JSON.stringify(b.recurrence ?? {}))
-  ]);
-}
-function normalizeFiles(values) {
-  if (!values || values.length === 0)
-    return void 0;
-  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(normalizeTestRunSummary).filter((value) => value.run_id.length > 0 && value.started_at.length > 0 && value.finished_at.length > 0 && value.recorded_at.length > 0).sort((a, b) => firstNonZeroComparison([
-    compareTimestampStrings(a.recorded_at, b.recorded_at),
-    a.run_id.localeCompare(b.run_id),
-    a.kind.localeCompare(b.kind)
-  ]));
-  return normalized.length > 0 ? normalized : void 0;
-}
-function normalizeNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
-}
-function normalizePositiveInteger(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : void 0;
-}
-function stringOrEmpty(value) {
-  return typeof value === "string" ? value : "";
-}
-function normalizeTestRunSummary(value) {
-  const runId = typeof value.run_id === "string" ? value.run_id.trim() : "";
-  const kind = value.kind === "test" || value.kind === "test-all" ? value.kind : "test";
-  const status = ITEM_TEST_RUN_STATUS_VALUES.has(value.status) ? value.status : "failed";
-  const summary = {
-    run_id: runId,
-    kind,
-    status,
-    started_at: stringOrEmpty(value.started_at),
-    finished_at: stringOrEmpty(value.finished_at),
-    recorded_at: stringOrEmpty(value.recorded_at),
-    attempt: normalizePositiveInteger(value.attempt),
-    resumed_from: value.resumed_from?.trim() || void 0,
-    passed: normalizeNonNegativeInteger(value.passed) ?? 0,
-    failed: normalizeNonNegativeInteger(value.failed) ?? 0,
-    skipped: normalizeNonNegativeInteger(value.skipped) ?? 0,
-    items: normalizeNonNegativeInteger(value.items),
-    linked_tests: normalizeNonNegativeInteger(value.linked_tests),
-    fail_on_skipped_triggered: value.fail_on_skipped_triggered === true ? true : void 0
-  };
-  deleteUndefinedFields(summary);
-  return summary;
-}
-function sortTests(values) {
-  if (!Array.isArray(values) || values.length === 0)
-    return void 0;
-  return [...values].map(normalizeLinkedTest).sort(compareLinkedTests);
-}
-function normalizeTrimmedStringList(value) {
-  if (!Array.isArray(value)) {
-    return void 0;
-  }
-  const normalized = [
-    ...new Set(value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0))
-  ].sort((a, b) => a.localeCompare(b));
-  return normalized.length > 0 ? normalized : void 0;
-}
-function isPlainObjectRecord(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function isUnsafeObjectKey(key) {
-  return key === "__proto__" || key === "constructor" || key === "prototype";
-}
-function normalizeStringRecord(value) {
-  if (!isPlainObjectRecord(value)) {
-    return void 0;
-  }
-  const entries = Object.entries(value).map(([key, recordValue]) => [key.trim(), String(recordValue).trim()]).filter(([key, recordValue]) => key.length > 0 && !isUnsafeObjectKey(key) && recordValue.length > 0).sort(([left], [right]) => left.localeCompare(right));
-  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
-}
-function normalizeNumericRecord(value) {
-  if (!isPlainObjectRecord(value)) {
-    return void 0;
-  }
-  const entries = Object.entries(value).map(([key, recordValue]) => [key.trim(), Number(recordValue)]).filter(([key, recordValue]) => key.length > 0 && !isUnsafeObjectKey(key) && Number.isFinite(recordValue)).sort(([left], [right]) => left.localeCompare(right));
-  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
-}
-function normalizeLinkedTestContextMode(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (!normalized || !LINKED_TEST_PM_CONTEXT_MODE_VALUES.has(normalized)) {
-    return void 0;
-  }
-  return normalized;
-}
-function normalizeLinkedTest(value) {
-  const test = {
-    command: value.command?.trim() || void 0,
-    path: value.path ? normalizePathValue(value.path) : void 0,
-    scope: value.scope,
-    timeout_seconds: typeof value.timeout_seconds === "number" && Number.isFinite(value.timeout_seconds) && value.timeout_seconds > 0 ? value.timeout_seconds : void 0,
-    pm_context_mode: normalizeLinkedTestContextMode(value.pm_context_mode),
-    env_set: normalizeStringRecord(value.env_set),
-    env_clear: normalizeTrimmedStringList(value.env_clear),
-    shared_host_safe: value.shared_host_safe === true ? true : void 0,
-    assert_stdout_contains: normalizeTrimmedStringList(value.assert_stdout_contains),
-    assert_stdout_regex: normalizeTrimmedStringList(value.assert_stdout_regex),
-    assert_stderr_contains: normalizeTrimmedStringList(value.assert_stderr_contains),
-    assert_stderr_regex: normalizeTrimmedStringList(value.assert_stderr_regex),
-    assert_stdout_min_lines: normalizeNonNegativeInteger(value.assert_stdout_min_lines),
-    assert_json_field_equals: normalizeStringRecord(value.assert_json_field_equals),
-    assert_json_field_gte: normalizeNumericRecord(value.assert_json_field_gte),
-    note: value.note?.trim() || void 0
-  };
-  deleteUndefinedFields(test);
-  return test;
-}
-function compareLinkedTests(a, b) {
-  return firstNonZeroComparison([
-    a.scope.localeCompare(b.scope),
-    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)),
-    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)
-    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 path2 = trimStringOrUndefined(record.path);
-    if (!path2)
-      continue;
-    const file = { path: normalizePathValue(path2) };
-    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 path2 = trimStringOrUndefined(record.path);
-    if (!command && !path2)
-      continue;
-    const test = {};
-    if (command)
-      test.command = command;
-    if (path2)
-      test.path = normalizePathValue(path2);
-    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 path2 = trimStringOrUndefined(record.path);
-    if (!path2)
-      continue;
-    const doc = { path: normalizePathValue(path2) };
-    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 normalizePlanStepEntry(entry) {
-  if (entry === null || typeof entry !== "object") {
-    return void 0;
-  }
-  const record = entry;
-  const id = trimStringOrUndefined(record.id);
-  const title = trimStringOrUndefined(record.title);
-  const statusRaw = trimStringOrUndefined(record.status);
-  const status = statusRaw && PLAN_STEP_STATUS_SET.has(statusRaw) ? statusRaw : void 0;
-  const orderRaw = record.order;
-  const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) ? orderRaw : typeof orderRaw === "string" && orderRaw.trim().length > 0 ? Number(orderRaw) : Number.NaN;
-  const created_at = typeof record.created_at === "string" ? record.created_at : "";
-  const updated_at = typeof record.updated_at === "string" ? record.updated_at : "";
-  if (!id || !title || !status || !Number.isFinite(order) || !created_at || !updated_at) {
-    return void 0;
-  }
-  const step = {
-    id,
-    order,
-    title,
-    status,
-    created_at,
-    updated_at
-  };
-  applyPlanStepOptionalFields(step, record);
-  return step;
-}
-function applyPlanStepOptionalFields(step, record) {
-  const stringFields = [
-    ["body", "body"],
-    ["owner", "owner"],
-    ["evidence", "evidence"],
-    ["blocked_reason", "blocked_reason"],
-    ["superseded_by", "superseded_by"]
-  ];
-  for (const [target, source] of stringFields) {
-    const value = trimStringOrUndefined(record[source]);
-    if (value) {
-      step[target] = value;
-    }
-  }
-  const completedAt = typeof record.completed_at === "string" ? record.completed_at : void 0;
-  if (completedAt && completedAt.length > 0) {
-    step.completed_at = completedAt;
-  }
-  const collectionFields = [
-    ["linked_items", "linked_items", normalizePlanStepLinks],
-    ["files", "files", normalizePlanStepFiles],
-    ["tests", "tests", normalizePlanStepTests],
-    ["docs", "docs", normalizePlanStepDocs]
-  ];
-  for (const [target, source, normalize] of collectionFields) {
-    const value = normalize(record[source]);
-    if (value) {
-      step[target] = value;
-    }
-  }
-}
-function normalizePlanSteps(value) {
-  if (!Array.isArray(value))
-    return void 0;
-  const out = value.flatMap((entry) => {
-    const step = normalizePlanStepEntry(entry);
-    return step ? [step] : [];
-  });
-  out.sort((left, right) => left.order - right.order);
-  return out.length > 0 ? out : void 0;
-}
-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) {
-  let start = 0;
-  while (start < body.length && body[start] === "\n") {
-    start += 1;
-  }
-  return body.slice(start).trimEnd();
-}
-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 emptyStringToUndefined(value) {
-  return value || void 0;
-}
-function copyExtensionFrontMatterFields(normalized, source) {
-  const targetRecord = normalized;
-  const sourceRecord = source;
-  for (const [key, value] of Object.entries(sourceRecord)) {
-    if (isUnsafeObjectKey(key) || Object.prototype.hasOwnProperty.call(targetRecord, key) || value === void 0) {
-      continue;
-    }
-    targetRecord[key] = value;
-  }
-}
-function coerceNormalizedRuntimeFields(normalized, runtimeContext) {
-  if (!runtimeContext?.fieldRegistry) {
-    return;
-  }
-  const record = normalized;
-  for (const definition of runtimeContext.fieldRegistry.definitions) {
-    const currentValue = record[definition.metadata_key];
-    if (currentValue === void 0) {
-      continue;
-    }
-    record[definition.metadata_key] = coerceRuntimeFieldValue(definition, currentValue, `metadata field "${definition.metadata_key}"`);
-  }
-}
-function assertNormalizedUnknownFields(normalized, runtimeContext) {
-  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
-    return;
-  }
-  const knownKeys = buildKnownFrontMatterKeys(runtimeContext);
-  const record = normalized;
-  const unknownKeys = Object.keys(record).filter((key) => !knownKeys.has(key)).sort((left, right) => left.localeCompare(right));
-  if (unknownKeys.length > 0 && runtimeContext.unknownFieldPolicy === "reject") {
-    validationError(`unknown schema fields are not allowed: ${unknownKeys.join(", ")}`);
-  }
-  if (unknownKeys.length > 0) {
-    runtimeContext.onWarning?.(`item_unknown_schema_fields:${unknownKeys.join(",")}`);
-  }
-}
-function normalizeFrontMatter(frontMatter, options = {}) {
-  const runtimeContext = resolveRuntimeSchemaValidationContext(options);
-  const normalizedStatus = normalizeStatusInput(frontMatter.status, runtimeContext?.statusRegistry) ?? frontMatter.status;
-  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,
-    pm_format_version: normalizeItemFormatVersion(frontMatter.pm_format_version),
-    source_type: trimStringOrUndefined(frontMatter.source_type),
-    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: emptyStringToUndefined(frontMatter.deadline),
-    reminders: sortReminders(frontMatter.reminders),
-    events: sortEvents(frontMatter.events),
-    closed_at: emptyStringToUndefined(frontMatter.closed_at),
-    assignee: trimStringOrUndefined(frontMatter.assignee),
-    source_owner: trimStringOrUndefined(frontMatter.source_owner),
-    author: emptyStringToUndefined(frontMatter.author),
-    estimated_minutes: frontMatter.estimated_minutes,
-    acceptance_criteria: frontMatter.acceptance_criteria ?? void 0,
-    design: frontMatter.design ?? void 0,
-    external_ref: frontMatter.external_ref ?? void 0,
-    definition_of_ready: trimStringOrUndefined(frontMatter.definition_of_ready),
-    order: frontMatter.order,
-    goal: trimStringOrUndefined(frontMatter.goal),
-    objective: trimStringOrUndefined(frontMatter.objective),
-    value: trimStringOrUndefined(frontMatter.value),
-    impact: trimStringOrUndefined(frontMatter.impact),
-    outcome: trimStringOrUndefined(frontMatter.outcome),
-    why_now: trimStringOrUndefined(frontMatter.why_now),
-    parent: trimStringOrUndefined(frontMatter.parent),
-    reviewer: trimStringOrUndefined(frontMatter.reviewer),
-    risk: frontMatter.risk ?? void 0,
-    confidence: normalizeConfidenceValue(frontMatter.confidence),
-    sprint: 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: 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: 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),
-    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)
-  };
-  copyExtensionFrontMatterFields(normalized, frontMatter);
-  coerceNormalizedRuntimeFields(normalized, runtimeContext);
-  assertNormalizedUnknownFields(normalized, runtimeContext);
-  deleteUndefinedFields(normalized);
-  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 normalizeParsedFrontMatter(frontMatter, options) {
-  return normalizeFrontMatter(frontMatter, { ...options, onWarning: void 0 });
-}
-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: normalizeParsedFrontMatter(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: normalizeParsedFrontMatter(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: normalizeParsedFrontMatter(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 ?? "")
-  };
-}
-
-// dist/core/item/id.js
-import crypto from "node:crypto";
-import path from "node:path";
-function normalizePrefix(input) {
-  const normalized = (input ?? "").trim().toLowerCase();
-  if (!normalized)
-    return "pm-";
-  return normalized.endsWith("-") ? normalized : `${normalized}-`;
-}
-function normalizeRawItemId(input) {
-  let normalized = input.trim().toLowerCase();
-  if (normalized.startsWith("#")) {
-    normalized = normalized.slice(1);
-  }
-  return normalized;
-}
-function normalizeItemId(input, prefix) {
-  const canonicalPrefix = normalizePrefix(prefix);
-  const normalized = normalizeRawItemId(input);
-  if (normalized.startsWith(canonicalPrefix)) {
-    return normalized;
-  }
-  return `${canonicalPrefix}${normalized}`;
-}
-function randomToken(length) {
-  let token = "";
-  for (let index = 0; index < length; index += 1) {
-    token += crypto.randomInt(0, 36).toString(36);
-  }
-  return token;
-}
-async function idExists(pmRoot, id) {
-  const checks = Object.values(TYPE_TO_FOLDER).flatMap((folder) => [
-    path.join(pmRoot, folder, `${id}.md`),
-    path.join(pmRoot, folder, `${id}.toon`)
-  ]);
-  for (const target of checks) {
-    if (await pathExists(target)) {
-      return true;
-    }
-  }
-  return false;
-}
-async function generateItemId(pmRoot, prefix) {
-  let tokenLength = 4;
-  let attempts = 0;
-  while (tokenLength <= 10) {
-    for (let i = 0; i < 32; i += 1) {
-      const id = `${normalizePrefix(prefix)}${randomToken(tokenLength)}`;
-      if (!await idExists(pmRoot, id)) {
-        return id;
-      }
-      attempts += 1;
-    }
-    tokenLength += 1;
-  }
-  throw new Error(`Unable to generate unique id after ${attempts} attempts`);
-}
-
-export {
-  readRuntimeFieldOptionValue,
-  coerceRuntimeFieldValue,
-  collectRuntimeCreateFieldValues,
-  collectRuntimeUpdateFieldValues,
-  BASELINE_ITEM_FORMAT_VERSION,
-  CURRENT_ITEM_FORMAT_VERSION,
-  effectiveItemFormatVersion,
-  normalizeItemFormatVersion,
-  classifyItemFormatVersion,
-  scanItemFormatVersions,
-  normalizeStatusInput,
-  normalizeStatusForRegistry,
-  isTerminalStatus,
-  findFirstMergeConflictMarker,
-  normalizeFrontMatter,
-  splitFrontMatter,
-  parseItemDocument,
-  serializeItemDocument,
-  canonicalDocument,
-  normalizePrefix,
-  normalizeRawItemId,
-  normalizeItemId,
-  generateItemId
-};
-//# sourceMappingURL=chunk-HK72NWAD.js.map
-
-//# debugId=4b8306b7-d6d7-5615-af29-66de3136cea2