@unbrained/pm-cli 2026.7.13 → 2026.7.14

package/dist/cli-bundle/chunks/{chunk-TNGLCRKS.js → chunk-GSEADLRH.js}

@@ -1,5 +1,5 @@
 
-!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]="d138c09e-ee75-5951-b241-652a22743908")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="e468cc5b-3706-5898-8d97-4deeb3bc0835")}catch(e){}}();
 import {
   CONFIDENCE_TEXT_VALUES,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
@@ -24,6 +24,7 @@ import {
   appendLineAtomic,
   coerceFiniteNumber,
   collectRegisteredItemFieldNames,
+  createEmptyExtensionHookRegistry,
   ensureDir,
   ensureRuntimeSchemaFileScaffold,
   evictOldestMemoEntries,
@@ -57,7 +58,17 @@ import {
   toErrorMessage,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-TGG7YGMC.js";
+} from "./chunk-GXXC7QSK.js";
+
+// dist/core/extensions/command-hook-context.js
+function createCoreCommandHookContext(options) {
+  return {
+    ...options,
+    hooks: createEmptyExtensionHookRegistry(),
+    profileEnabled: Boolean(options.globalOptions.profile),
+    migrationBlockers: []
+  };
+}
 
 // dist/core/shared/serial-queue.js
 function createSerialQueue() {
@@ -158,7 +169,7 @@ function getActiveCommandResult() {
   return activeCommandResult;
 }
 function recordAfterCommandAffectedItem(item) {
-  if (!item || (activeExtensionHooks?.afterCommand?.length ?? 0) === 0) {
+  if (!item) {
     return;
   }
   activeAfterCommandAffectedItems.push(item);
@@ -2208,2103 +2219,2103 @@ function resolveIsoOrRelative(input, now = /* @__PURE__ */ new Date(), fieldLabe
   return new Date(timestamp).toISOString();
 }
 
-// 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;
+// dist/core/lock/lock.js
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+function parseLockInfo(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {
+      info: null,
+      warnings: ["lock_info_invalid_json"]
+    };
   }
-  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))
-    ])
-  ];
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return {
+      info: null,
+      warnings: ["lock_info_invalid_shape"]
+    };
+  }
+  const candidate = parsed;
+  const id = candidate.id;
+  const pid = candidate.pid;
+  const owner = candidate.owner;
+  const createdAt = candidate.created_at;
+  const ttlSeconds = candidate.ttl_seconds;
+  if (typeof id !== "string" || typeof pid !== "number" || !Number.isFinite(pid) || typeof owner !== "string" || typeof createdAt !== "string" || typeof ttlSeconds !== "number" || !Number.isFinite(ttlSeconds)) {
+    return {
+      info: null,
+      warnings: ["lock_info_invalid_shape"]
+    };
+  }
+  return {
+    info: {
+      id,
+      pid,
+      owner,
+      created_at: createdAt,
+      ttl_seconds: ttlSeconds
+    },
+    warnings: []
+  };
 }
-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;
+async function readLockInfo(lockPath) {
+  try {
+    const raw = await fs.readFile(lockPath, "utf8");
+    await runActiveOnReadHooks({
+      path: lockPath,
+      scope: "project"
+    });
+    return parseLockInfo(raw);
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return {
+        info: null,
+        warnings: []
+      };
     }
+    return {
+      info: null,
+      warnings: ["lock_info_read_failed"]
+    };
   }
-  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 [];
+function isErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+async function emitLockWriteHook(lockPath, op) {
+  await runActiveOnWriteHooks({
+    path: lockPath,
+    scope: "project",
+    op
+  });
+}
+function buildLockPayload(id, owner, ttlSeconds) {
+  return {
+    id,
+    pid: process.pid,
+    owner,
+    created_at: nowIso(),
+    ttl_seconds: ttlSeconds
+  };
+}
+async function createLockFile(lockPath, id, owner, ttlSeconds) {
+  await fs.mkdir(path.dirname(lockPath), { recursive: true });
+  const handle = await fs.open(lockPath, "wx");
+  try {
+    await handle.writeFile(`${JSON.stringify(buildLockPayload(id, owner, ttlSeconds), null, 2)}
+`, "utf8");
+  } finally {
+    await handle.close();
   }
-  return [String(value).trim()].filter((entry) => entry.length > 0);
+  await emitLockWriteHook(lockPath, "lock:create");
 }
-function parseBooleanValue(raw, label) {
-  if (typeof raw === "boolean") {
-    return raw;
+async function unlinkLockWithHook(lockPath, op) {
+  try {
+    await fs.unlink(lockPath);
+    await emitLockWriteHook(lockPath, op);
+    return true;
+  } catch {
+    return false;
   }
-  if (typeof raw === "number") {
-    if (raw === 1) {
-      return true;
-    }
-    if (raw === 0) {
-      return false;
+}
+function isStaleLock(info, ttlSeconds) {
+  const createdAtMs = info?.created_at ? Date.parse(info.created_at) : Number.NaN;
+  const ageMs = Number.isFinite(createdAtMs) ? Date.now() - createdAtMs : Number.POSITIVE_INFINITY;
+  return ageMs > ttlSeconds * 1e3;
+}
+function lockOwnerSuffix(info) {
+  return info?.owner ? ` (owner ${info.owner})` : "";
+}
+var LOCK_WAIT_INITIAL_DELAY_MS = 25;
+var LOCK_WAIT_MAX_DELAY_MS = 200;
+var LOCK_CONFLICT_RETRY_HINT_MS = 250;
+var MAX_STALE_LOCK_REMOVALS = 3;
+var STALE_CLEANUP_GATE_SUFFIX = ".stale-cleanup";
+var STALE_CLEANUP_GATE_OWNER_FILE = "owner.json";
+var STALE_CLEANUP_GATE_STALE_MS = 1e4;
+var STALE_CLEANUP_GATE_MAX_ACTIVE_MS = 5 * 6e4;
+function parseNonNegativeIntegerWaitMs(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!/^\d+$/.test(trimmed)) {
+      return void 0;
     }
+    const parsed = Number(trimmed);
+    return Number.isSafeInteger(parsed) ? parsed : void 0;
   }
-  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;
-    }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return Math.trunc(value);
   }
-  throw new PmCliError(`${label} must be one of true|false|1|0|yes|no`, EXIT_CODE.USAGE);
+  return void 0;
 }
-function parseNumberValue(raw, label) {
-  if (typeof raw === "number" && Number.isFinite(raw)) {
-    return raw;
+function resolveLockWaitMs(waitMs) {
+  const envRaw = process.env.PM_LOCK_WAIT_MS;
+  const envParsed = parseNonNegativeIntegerWaitMs(envRaw);
+  if (envParsed !== void 0) {
+    return envParsed;
   }
-  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);
+  const callerParsed = parseNonNegativeIntegerWaitMs(waitMs);
+  if (callerParsed !== void 0) {
+    return callerParsed;
   }
-  return parsed;
+  return 0;
 }
-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));
+function sleepWithJitter(baseDelayMs) {
+  const jitteredMs = Math.max(1, Math.round(baseDelayMs * (0.5 + Math.random())));
+  return new Promise((resolve) => setTimeout(resolve, jitteredMs));
+}
+function buildLockConflictError(id, info, waitedMs) {
+  const waitedSuffix = waitedMs > 0 ? ` after waiting ${waitedMs}ms` : "";
+  return new PmCliError(`Item ${id} is locked${lockOwnerSuffix(info)}${waitedSuffix}`, EXIT_CODE.CONFLICT, {
+    code: "lock_conflict",
+    recovery: {
+      retry_after_ms: LOCK_CONFLICT_RETRY_HINT_MS
     }
-    return values;
-  }
-  const scalarRaw = Array.isArray(rawValue) ? rawValue[rawValue.length - 1] : rawValue;
-  if (scalarRaw === void 0) {
-    return void 0;
+  });
+}
+function resolveLockOverrideRelease(result) {
+  if (typeof result === "function") {
+    return result;
   }
-  if (definition.type === "number") {
-    return parseNumberValue(scalarRaw, label);
+  if (typeof result === "object" && result !== null && "release" in result) {
+    const release = result.release;
+    return typeof release === "function" ? release : null;
   }
-  if (definition.type === "boolean") {
-    return parseBooleanValue(scalarRaw, label);
+  return null;
+}
+function throwIfStaleLockNeedsForce(id, lockInfo, force, forceRequired) {
+  if (!force && forceRequired) {
+    const warningSuffix = lockInfo.warnings.length > 0 ? ` (${lockInfo.warnings.join(",")})` : "";
+    throw new PmCliError(`Item ${id} lock is stale${warningSuffix}; rerun with --force when supported for this command`, EXIT_CODE.CONFLICT);
   }
-  return typeof scalarRaw === "string" ? scalarRaw : String(scalarRaw);
 }
-function shouldRequireFieldOnCreate(definition, itemTypeName) {
-  if (!definition.required && !definition.required_on_create) {
-    return false;
+function parseStaleCleanupGateOwner(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
   }
-  if (definition.required_types.length === 0) {
-    return true;
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
   }
-  if (!itemTypeName) {
-    return false;
+  const candidate = parsed;
+  const pid = candidate.pid;
+  const token = candidate.token;
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof token !== "string" || token.length === 0) {
+    return null;
   }
-  return definition.required_types.map((value) => value.toLowerCase()).includes(itemTypeName.trim().toLowerCase());
+  return { pid, token };
 }
-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);
+async function readStaleCleanupGateOwner(gatePath) {
+  try {
+    return parseStaleCleanupGateOwner(await fs.readFile(path.join(gatePath, STALE_CLEANUP_GATE_OWNER_FILE), "utf8"));
+  } catch {
+    return null;
   }
-  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;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (isErrno(error, "ESRCH")) {
+      return false;
     }
-    seen.add(definition.metadata_key);
-    values[definition.metadata_key] = coerceRuntimeFieldValue(definition, rawValue);
+    return true;
   }
-  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;
+async function removeStaleCleanupGateDirectory(gatePath) {
+  try {
+    await fs.rm(gatePath, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
   }
-  return BASELINE_ITEM_FORMAT_VERSION;
 }
-function normalizeItemFormatVersion(value) {
-  if (typeof value !== "number" || !Number.isInteger(value) || value <= BASELINE_ITEM_FORMAT_VERSION) {
-    return void 0;
+async function releaseStaleCleanupGate(gatePath, token) {
+  const owner = await readStaleCleanupGateOwner(gatePath);
+  if (owner === null || owner.token !== token) {
+    return;
   }
-  return value;
+  await removeStaleCleanupGateDirectory(gatePath);
 }
-function classifyItemFormatVersion(version, current = CURRENT_ITEM_FORMAT_VERSION) {
-  if (version < current) {
-    return "outdated";
+async function tryCreateStaleCleanupGate(gatePath) {
+  try {
+    await fs.mkdir(gatePath);
+  } catch (error) {
+    if (isErrno(error, "EEXIST")) {
+      return null;
+    }
+    return null;
   }
-  if (version > current) {
-    return "ahead";
+  const owner = { pid: process.pid, token: randomUUID() };
+  try {
+    await fs.writeFile(path.join(gatePath, STALE_CLEANUP_GATE_OWNER_FILE), `${JSON.stringify(owner)}
+`, "utf8");
+  } catch {
+    await removeStaleCleanupGateDirectory(gatePath);
+    return null;
   }
-  return "current";
+  return owner;
 }
-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);
+async function removeExpiredStaleCleanupGate(gatePath) {
+  let gateAgeMs;
+  try {
+    const stats = await fs.stat(gatePath);
+    gateAgeMs = Date.now() - stats.mtimeMs;
+    if (gateAgeMs <= STALE_CLEANUP_GATE_STALE_MS) {
+      return false;
     }
+  } catch (error) {
+    return isErrno(error, "ENOENT");
   }
-  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;
-    }
+  const owner = await readStaleCleanupGateOwner(gatePath);
+  if (owner !== null && isProcessAlive(owner.pid) && gateAgeMs <= STALE_CLEANUP_GATE_MAX_ACTIVE_MS) {
+    return false;
   }
-  if (typeof value !== "string") {
-    return void 0;
+  return removeStaleCleanupGateDirectory(gatePath);
+}
+async function acquireStaleCleanupGate(lockPath, _id) {
+  const gatePath = `${lockPath}${STALE_CLEANUP_GATE_SUFFIX}`;
+  const owner = await tryCreateStaleCleanupGate(gatePath);
+  if (owner !== null) {
+    return async () => releaseStaleCleanupGate(gatePath, owner.token);
   }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) {
-    return void 0;
+  if (!await removeExpiredStaleCleanupGate(gatePath)) {
+    return null;
   }
-  const canonical = STATUS_ALIAS_MAP[normalized] ?? normalized;
-  if (!STATUS_VALUES.includes(canonical)) {
-    return void 0;
+  const recoveredOwner = await tryCreateStaleCleanupGate(gatePath);
+  if (recoveredOwner === null) {
+    return null;
   }
-  return canonical;
-}
-function normalizeStatusForRegistry(status, registry) {
-  return normalizeStatusInput(status, registry) ?? status;
-}
-function isTerminalStatus(status, registry) {
-  return registry.terminal_statuses.has(normalizeStatusForRegistry(status, registry));
+  return async () => releaseStaleCleanupGate(gatePath, recoveredOwner.token);
 }
-
-// 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;
+async function removeConfirmedStaleLock(params) {
+  const releaseCleanupGate = await acquireStaleCleanupGate(params.lockPath, params.id);
+  if (releaseCleanupGate === null) {
+    return {
+      lockInfo: params.fallbackLockInfo,
+      shouldRetryCreate: false,
+      staleRemovalCounted: false
+    };
+  }
+  try {
+    const currentLockInfo = await readLockInfo(params.lockPath);
+    if (currentLockInfo.info === null && currentLockInfo.warnings.length === 0) {
+      return {
+        lockInfo: currentLockInfo,
+        shouldRetryCreate: true,
+        staleRemovalCounted: false
+      };
     }
-    const key = line.slice(0, separatorIndex + 2);
-    const value = line.slice(separatorIndex + 2);
-    if (!value.startsWith('"')) {
-      return line;
+    if (!isStaleLock(currentLockInfo.info, params.ttlSeconds)) {
+      return {
+        lockInfo: currentLockInfo,
+        shouldRetryCreate: false,
+        staleRemovalCounted: false
+      };
     }
-    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;
+    throwIfStaleLockNeedsForce(params.id, currentLockInfo, params.force, params.forceRequiredForStaleLock);
+    if (params.staleRemovals >= MAX_STALE_LOCK_REMOVALS) {
+      throw buildLockConflictError(params.id, currentLockInfo.info, Date.now() - params.startedAtMs);
     }
-    return { value: decodeToon(escaped), usedScalarBracketEscape: true };
+    return {
+      lockInfo: currentLockInfo,
+      shouldRetryCreate: await unlinkLockWithHook(params.lockPath, "lock:stale_remove"),
+      staleRemovalCounted: true
+    };
+  } finally {
+    await releaseCleanupGate();
   }
 }
-
-// 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;
+async function acquireLock(pmRoot, id, ttlSeconds, owner, force = false, forceRequiredForStaleLock = true, waitMs) {
+  const lockOverride = await runActiveServiceOverride("lock_acquire", {
+    pm_root: pmRoot,
+    id,
+    ttl_seconds: ttlSeconds,
+    owner,
+    force,
+    force_required_for_stale_lock: forceRequiredForStaleLock
+  });
+  if (lockOverride.handled) {
+    const release = resolveLockOverrideRelease(lockOverride.result);
+    if (release) {
+      return async () => {
+        await Promise.resolve(release());
+        await runActiveServiceOverride("lock_release", {
+          pm_root: pmRoot,
+          id,
+          owner
+        });
+      };
+    }
+  }
+  const lockPath = getLockPath(pmRoot, id);
+  const waitBudgetMs = resolveLockWaitMs(waitMs);
+  const startedAtMs = Date.now();
+  let staleRemovals = 0;
+  let backoffMs = LOCK_WAIT_INITIAL_DELAY_MS;
+  for (; ; ) {
+    try {
+      await createLockFile(lockPath, id, owner, ttlSeconds);
+      return async () => {
+        await unlinkLockWithHook(lockPath, "lock:release");
+        await runActiveServiceOverride("lock_release", {
+          pm_root: pmRoot,
+          id,
+          owner
+        });
+      };
+    } catch (error) {
+      if (!isErrno(error, "EEXIST")) {
+        throw new PmCliError(`Failed to acquire lock for ${id}: ${toErrorMessage(error)}`, EXIT_CODE.GENERIC_FAILURE);
+      }
+      let lockInfo = await readLockInfo(lockPath);
+      if (isStaleLock(lockInfo.info, ttlSeconds)) {
+        const staleRemoval = await removeConfirmedStaleLock({
+          lockPath,
+          id,
+          ttlSeconds,
+          force,
+          forceRequiredForStaleLock,
+          staleRemovals,
+          waitBudgetMs,
+          startedAtMs,
+          fallbackLockInfo: lockInfo
+        });
+        lockInfo = staleRemoval.lockInfo;
+        if (staleRemoval.staleRemovalCounted) {
+          staleRemovals += 1;
+        }
+        if (staleRemoval.shouldRetryCreate) {
+          continue;
+        }
+      }
+      const elapsedMs = Date.now() - startedAtMs;
+      if (waitBudgetMs === 0 || elapsedMs >= waitBudgetMs) {
+        throw buildLockConflictError(id, lockInfo.info, waitBudgetMs === 0 ? 0 : elapsedMs);
+      }
+      await sleepWithJitter(Math.min(backoffMs, waitBudgetMs - elapsedMs));
+      backoffMs = Math.min(backoffMs * 2, LOCK_WAIT_MAX_DELAY_MS);
     }
-    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
-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;
-    }
+// 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;
   }
-  return 0;
+  const [first, ...rest] = segments;
+  return `${first}${rest.map((segment) => `${segment.slice(0, 1).toUpperCase()}${segment.slice(1)}`).join("")}`;
 }
-function deleteUndefinedFields(record) {
-  for (const [key, value] of Object.entries(record)) {
-    if (value === void 0) {
-      delete record[key];
+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;
 }
-var REQUIRED_STRING_FIELDS = [
-  "id",
-  "title",
-  "description",
-  "created_at",
-  "updated_at"
-];
-var STATIC_ITEM_METADATA_FIELD_SET = new Set(ITEM_METADATA_KEY_ORDER);
-function resolveRuntimeSchemaValidationContext(options) {
-  if (!options?.schema) {
-    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);
   }
-  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 (typeof value === "string") {
+    return value.split(/[,\n|]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
   }
-  if (definition.required_types.length === 0) {
-    return true;
+  if (value === void 0 || value === null) {
+    return [];
   }
-  return definition.required_types.map((value) => value.toLowerCase()).includes(typeName.trim().toLowerCase());
-}
-function validationError(message) {
-  throw new PmCliError(`Invalid item metadata: ${message}`, EXIT_CODE.GENERIC_FAILURE);
+  return [String(value).trim()].filter((entry) => entry.length > 0);
 }
-function buildKnownItemMetadataKeys(runtimeContext) {
-  const knownKeys = new Set(STATIC_ITEM_METADATA_FIELD_SET);
-  for (const definition of runtimeContext.fieldRegistry?.definitions ?? []) {
-    knownKeys.add(definition.metadata_key);
+function parseBooleanValue(raw, label) {
+  if (typeof raw === "boolean") {
+    return raw;
   }
-  for (const fieldName of runtimeContext.extensionFieldNames) {
-    knownKeys.add(fieldName);
+  if (typeof raw === "number") {
+    if (raw === 1) {
+      return true;
+    }
+    if (raw === 0) {
+      return false;
+    }
   }
-  return knownKeys;
-}
-function assertItemMetadataCondition(condition, message) {
-  if (!condition) {
-    validationError(message);
+  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 assertTimestampField(record, fieldName) {
-  const rawValue = record[fieldName];
-  assertItemMetadataCondition(typeof rawValue === "string", `${fieldName} must be a string`);
-  const timestamp = rawValue;
-  assertItemMetadataCondition(isTimestampLiteral(timestamp), `${fieldName} must be a valid ISO timestamp`);
-}
-function assertPositiveIntegerField(record, fieldName, messagePrefix) {
-  const value = record[fieldName];
-  if (value === void 0) {
-    return;
+function parseNumberValue(raw, label) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw;
   }
-  assertItemMetadataCondition(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;
+  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);
   }
-  assertItemMetadataCondition(typeof value === "string", `${messagePrefix} must be a string`);
-  assertItemMetadataCondition(isTimestampLiteral(value), `${messagePrefix} must be a valid ISO timestamp`);
+  return parsed;
 }
-function assertRecurrenceWeekdays(value) {
-  if (value === void 0) {
-    return;
+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;
   }
-  assertItemMetadataCondition(Array.isArray(value), "event.recurrence.by_weekday must be an array");
-  for (const weekday of value) {
-    assertItemMetadataCondition(typeof weekday === "string", "event.recurrence.by_weekday entries must be strings");
-    const normalizedWeekday = weekday.trim().toLowerCase();
-    assertItemMetadataCondition(RECURRENCE_WEEKDAY_VALUES.includes(normalizedWeekday), `event.recurrence.by_weekday entries must be one of: ${RECURRENCE_WEEKDAY_VALUES.join(", ")}`);
+  const scalarRaw = Array.isArray(rawValue) ? rawValue[rawValue.length - 1] : rawValue;
+  if (scalarRaw === void 0) {
+    return void 0;
   }
-}
-function assertRecurrenceMonthDays(value) {
-  if (value === void 0) {
-    return;
+  if (definition.type === "number") {
+    return parseNumberValue(scalarRaw, label);
   }
-  assertItemMetadataCondition(Array.isArray(value), "event.recurrence.by_month_day must be an array");
-  for (const day of value) {
-    assertItemMetadataCondition(typeof day === "number" && Number.isInteger(day) && day >= 1 && day <= 31, "event.recurrence.by_month_day entries must be integers 1..31");
+  if (definition.type === "boolean") {
+    return parseBooleanValue(scalarRaw, label);
   }
+  return typeof scalarRaw === "string" ? scalarRaw : String(scalarRaw);
 }
-function assertRecurrenceExdates(value) {
-  if (value === void 0) {
-    return;
+function shouldRequireFieldOnCreate(definition, itemTypeName) {
+  if (!definition.required && !definition.required_on_create) {
+    return false;
   }
-  assertItemMetadataCondition(Array.isArray(value), "event.recurrence.exdates must be an array");
-  for (const exdate of value) {
-    assertItemMetadataCondition(typeof exdate === "string", "event.recurrence.exdates entries must be strings");
-    assertItemMetadataCondition(isTimestampLiteral(exdate), "event.recurrence.exdates entries must be valid ISO timestamps");
+  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 assertValidRecurrenceRule(recurrence) {
-  assertItemMetadataCondition(typeof recurrence === "object" && recurrence !== null && !Array.isArray(recurrence), "event.recurrence must be an object");
-  const recurrenceRecord = recurrence;
-  assertItemMetadataCondition(typeof recurrenceRecord.freq === "string", "event.recurrence.freq must be a string");
-  const frequency = recurrenceRecord.freq.trim().toLowerCase();
-  assertItemMetadataCondition(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 assertRequiredItemMetadataFields(record) {
-  for (const fieldName of REQUIRED_STRING_FIELDS) {
-    assertItemMetadataCondition(typeof record[fieldName] === "string", `${fieldName} is required and must be a string`);
-  }
-  const itemType = record.type;
-  assertItemMetadataCondition(typeof itemType === "string" && itemType.trim().length > 0, "type must be a non-empty string");
-  const formatVersion = record.pm_format_version;
-  if (formatVersion !== void 0) {
-    assertItemMetadataCondition(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 assertStatusItemMetadataField(record, runtimeContext) {
-  const status = record.status;
-  assertItemMetadataCondition(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];
-  assertItemMetadataCondition(normalizedStatus !== void 0, `status must be one of: ${statusDomain.join(", ")}`);
-}
-function assertPriorityAndTags(record) {
-  const priority = record.priority;
-  assertItemMetadataCondition(typeof priority === "number" && Number.isInteger(priority) && [0, 1, 2, 3, 4].includes(priority), "priority must be an integer 0..4");
-  const tags = record.tags;
-  assertItemMetadataCondition(Array.isArray(tags), "tags must be an array");
-  for (const tag of tags) {
-    assertItemMetadataCondition(typeof tag === "string", "tags entries must be strings");
+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 assertConfidenceItemMetadataField(record) {
-  const confidence = record.confidence;
-  if (confidence === void 0) {
-    return;
-  }
-  if (typeof confidence === "number") {
-    assertItemMetadataCondition(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);
-    assertItemMetadataCondition(isKnownTextConfidence, `confidence string value must be one of: ${[...CONFIDENCE_TEXT_VALUES, "med"].join(", ")}`);
-    return;
+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);
   }
-  assertItemMetadataCondition(false, "confidence must be a number or string");
+  return values;
 }
-function assertSeverityItemMetadataField(record) {
-  const severity = record.severity;
-  if (severity === void 0) {
-    return;
-  }
-  if (typeof severity !== "string") {
-    validationError("severity must be a string");
+
+// 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;
   }
-  const normalizedSeverity = severity.trim().toLowerCase();
-  const isKnownSeverity = normalizedSeverity === "med" || ISSUE_SEVERITY_VALUES.includes(normalizedSeverity);
-  assertItemMetadataCondition(isKnownSeverity, `severity value must be one of: ${[...ISSUE_SEVERITY_VALUES, "med"].join(", ")}`);
+  return BASELINE_ITEM_FORMAT_VERSION;
 }
-function assertRegressionItemMetadataField(record) {
-  if (record.regression !== void 0 && typeof record.regression !== "boolean") {
-    validationError("regression must be a boolean");
+function normalizeItemFormatVersion(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= BASELINE_ITEM_FORMAT_VERSION) {
+    return void 0;
   }
+  return value;
 }
-function assertReminderEntries(record) {
-  const reminders = record.reminders;
-  if (reminders === void 0) {
-    return;
+function classifyItemFormatVersion(version, current = CURRENT_ITEM_FORMAT_VERSION) {
+  if (version < current) {
+    return "outdated";
   }
-  assertItemMetadataCondition(Array.isArray(reminders), "reminders must be an array");
-  for (const reminder of reminders) {
-    assertItemMetadataCondition(typeof reminder === "object" && reminder !== null && !Array.isArray(reminder), "reminders entries must be objects");
-    const reminderRecord = reminder;
-    assertItemMetadataCondition(typeof reminderRecord.at === "string", "reminder.at must be a string");
-    assertItemMetadataCondition(isTimestampLiteral(reminderRecord.at), "reminder.at must be a valid ISO timestamp");
-    assertItemMetadataCondition(typeof reminderRecord.text === "string", "reminder.text must be a string");
-    assertItemMetadataCondition(reminderRecord.text.trim().length > 0, "reminder.text must not be empty");
+  if (version > current) {
+    return "ahead";
   }
+  return "current";
 }
-function assertEventStringFields(eventRecord) {
-  for (const stringField of [
-    "title",
-    "description",
-    "location",
-    "timezone"
-  ]) {
-    if (eventRecord[stringField] !== void 0) {
-      assertItemMetadataCondition(typeof eventRecord[stringField] === "string", `event.${stringField} must be a string`);
-      assertItemMetadataCondition(eventRecord[stringField].trim().length > 0, `event.${stringField} must not be empty`);
+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))
+  };
 }
-function assertEventRecurrence(eventRecord) {
-  if (eventRecord.recurrence === void 0) {
-    return;
+
+// 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;
+    }
   }
-  assertValidRecurrenceRule(eventRecord.recurrence);
-  if (eventRecord.recurrence.until !== void 0) {
-    assertItemMetadataCondition(compareTimestampStrings(eventRecord.recurrence.until, eventRecord.start_at) >= 0, "event.recurrence.until must be at or after event.start_at");
+  if (typeof value !== "string") {
+    return void 0;
   }
-}
-function assertCalendarEventEntry(event) {
-  assertItemMetadataCondition(typeof event === "object" && event !== null && !Array.isArray(event), "events entries must be objects");
-  const eventRecord = event;
-  assertItemMetadataCondition(typeof eventRecord.start_at === "string", "event.start_at must be a string");
-  assertItemMetadataCondition(isTimestampLiteral(eventRecord.start_at), "event.start_at must be a valid ISO timestamp");
-  if (eventRecord.end_at !== void 0) {
-    assertItemMetadataCondition(typeof eventRecord.end_at === "string", "event.end_at must be a string");
-    assertItemMetadataCondition(isTimestampLiteral(eventRecord.end_at), "event.end_at must be a valid ISO timestamp");
-    assertItemMetadataCondition(compareTimestampStrings(eventRecord.end_at, eventRecord.start_at) > 0, "event.end_at must be after event.start_at");
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) {
+    return void 0;
   }
-  assertEventStringFields(eventRecord);
-  if (eventRecord.all_day !== void 0) {
-    assertItemMetadataCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
+  const canonical = STATUS_ALIAS_MAP[normalized] ?? normalized;
+  if (!STATUS_VALUES.includes(canonical)) {
+    return void 0;
   }
-  assertEventRecurrence(eventRecord);
+  return canonical;
 }
-function assertCalendarEvents(record) {
-  const events = record.events;
-  if (events === void 0) {
-    return;
-  }
-  assertItemMetadataCondition(Array.isArray(events), "events must be an array");
-  for (const event of events) {
-    assertCalendarEventEntry(event);
-  }
+function normalizeStatusForRegistry(status, registry) {
+  return normalizeStatusInput(status, registry) ?? status;
 }
-function assertOptionalStringFields(record) {
-  for (const fieldName of [
-    "source_type",
-    "source_owner",
-    "design",
-    "external_ref"
-  ]) {
-    const value = record[fieldName];
-    if (value !== void 0) {
-      assertItemMetadataCondition(typeof value === "string", `${fieldName} must be a string`);
+function isTerminalStatus(status, registry) {
+  return registry.terminal_statuses.has(normalizeStatusForRegistry(status, registry));
+}
+
+// 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 assertTypeOptionsField(record) {
-  const typeOptions = record.type_options;
-  if (typeOptions === void 0) {
-    return;
-  }
-  assertItemMetadataCondition(typeof typeOptions === "object" && typeOptions !== null && !Array.isArray(typeOptions), "type_options must be an object");
-  for (const [optionKey, optionValue] of Object.entries(typeOptions)) {
-    assertItemMetadataCondition(optionKey.trim().length > 0, "type_options keys must be non-empty");
-    assertItemMetadataCondition(typeof optionValue === "string", "type_options values must be strings");
-    const optionText = optionValue;
-    assertItemMetadataCondition(optionText.trim().length > 0, "type_options values must be non-empty strings");
+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 };
   }
 }
-function coerceRuntimeItemMetadataFields(record, itemType, runtimeContext) {
-  if (!runtimeContext?.fieldRegistry) {
-    return;
+
+// dist/core/shared/conflict-markers.js
+var CONFLICT_MARKER_PATTERN = /^\s*(<<<<<<<|=======|>>>>>>>)(?:\s.*)?$/;
+function findMergeConflictMarkers(content) {
+  if (content.length === 0) {
+    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}`);
-      }
+  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;
     }
-    try {
-      record[definition.metadata_key] = coerceRuntimeFieldValue(definition, fieldValue, `metadata field "${definition.metadata_key}"`);
-    } catch (error) {
-      validationError(String(error?.message).replace(/^Invalid\s+/u, ""));
-    }
+    const marker = markerMatch[1];
+    matches.push({
+      line: index + 1,
+      marker,
+      text: line
+    });
   }
+  return matches;
 }
-function assertRuntimeUnknownItemMetadataFields(record, runtimeContext) {
-  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
-    return;
-  }
-  const knownKeys = buildKnownItemMetadataKeys(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 findFirstMergeConflictMarker(content) {
+  const matches = findMergeConflictMarkers(content);
+  return matches[0];
+}
+
+// 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 assertValidItemMetadata(itemMetadata, runtimeContext) {
-  assertItemMetadataCondition(typeof itemMetadata === "object" && itemMetadata !== null && !Array.isArray(itemMetadata), "item metadata must be an object");
-  const record = itemMetadata;
-  const itemType = assertRequiredItemMetadataFields(record);
-  assertStatusItemMetadataField(record, runtimeContext);
-  assertPriorityAndTags(record);
-  assertConfidenceItemMetadataField(record);
-  assertSeverityItemMetadataField(record);
-  assertRegressionItemMetadataField(record);
-  assertTimestampField(record, "created_at");
-  assertTimestampField(record, "updated_at");
-  if (record.deadline !== void 0) {
-    assertTimestampField(record, "deadline");
+function deleteUndefinedFields(record) {
+  for (const [key, value] of Object.entries(record)) {
+    if (value === void 0) {
+      delete record[key];
+    }
   }
-  assertReminderEntries(record);
-  assertCalendarEvents(record);
-  assertOptionalTimestampString(record, "closed_at", "closed_at");
-  assertOptionalStringFields(record);
-  assertTypeOptionsField(record);
-  coerceRuntimeItemMetadataFields(record, itemType, runtimeContext);
-  assertRuntimeUnknownItemMetadataFields(record, runtimeContext);
 }
-function sortDependencies(values) {
-  if (!values || values.length === 0)
+var REQUIRED_STRING_FIELDS = [
+  "id",
+  "title",
+  "description",
+  "created_at",
+  "updated_at"
+];
+var STATIC_ITEM_METADATA_FIELD_SET = new Set(ITEM_METADATA_KEY_ORDER);
+function resolveRuntimeSchemaValidationContext(options) {
+  if (!options?.schema) {
     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 ?? "");
-  });
+  }
+  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 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 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 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 validationError(message) {
+  throw new PmCliError(`Invalid item metadata: ${message}`, EXIT_CODE.GENERIC_FAILURE);
 }
-function normalizeRecurrenceRule(value) {
-  if (!value) {
-    return void 0;
-  }
-  const normalizedFrequency = value.freq.trim().toLowerCase();
-  if (!RECURRENCE_FREQUENCY_VALUES.includes(normalizedFrequency)) {
-    return void 0;
+function buildKnownItemMetadataKeys(runtimeContext) {
+  const knownKeys = new Set(STATIC_ITEM_METADATA_FIELD_SET);
+  for (const definition of runtimeContext.fieldRegistry?.definitions ?? []) {
+    knownKeys.add(definition.metadata_key);
   }
-  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];
-    }
+  for (const fieldName of runtimeContext.extensionFieldNames) {
+    knownKeys.add(fieldName);
   }
-  return normalized;
+  return knownKeys;
 }
-function sortEvents(values) {
-  if (!Array.isArray(values) || values.length === 0) {
-    return void 0;
+function assertItemMetadataCondition(condition, message) {
+  if (!condition) {
+    validationError(message);
   }
-  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 assertTimestampField(record, fieldName) {
+  const rawValue = record[fieldName];
+  assertItemMetadataCondition(typeof rawValue === "string", `${fieldName} must be a string`);
+  const timestamp = rawValue;
+  assertItemMetadataCondition(isTimestampLiteral(timestamp), `${fieldName} must be a valid ISO timestamp`);
 }
-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 assertPositiveIntegerField(record, fieldName, messagePrefix) {
+  const value = record[fieldName];
+  if (value === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(typeof value === "number" && Number.isInteger(value) && value >= 1, `${messagePrefix} must be an integer >= 1`);
 }
-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 assertOptionalTimestampString(record, fieldName, messagePrefix) {
+  const value = record[fieldName];
+  if (value === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(typeof value === "string", `${messagePrefix} must be a string`);
+  assertItemMetadataCondition(isTimestampLiteral(value), `${messagePrefix} must be a valid ISO timestamp`);
 }
-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 assertRecurrenceWeekdays(value) {
+  if (value === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(Array.isArray(value), "event.recurrence.by_weekday must be an array");
+  for (const weekday of value) {
+    assertItemMetadataCondition(typeof weekday === "string", "event.recurrence.by_weekday entries must be strings");
+    const normalizedWeekday = weekday.trim().toLowerCase();
+    assertItemMetadataCondition(RECURRENCE_WEEKDAY_VALUES.includes(normalizedWeekday), `event.recurrence.by_weekday entries must be one of: ${RECURRENCE_WEEKDAY_VALUES.join(", ")}`);
+  }
 }
-function normalizeNonNegativeInteger(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+function assertRecurrenceMonthDays(value) {
+  if (value === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(Array.isArray(value), "event.recurrence.by_month_day must be an array");
+  for (const day of value) {
+    assertItemMetadataCondition(typeof day === "number" && Number.isInteger(day) && day >= 1 && day <= 31, "event.recurrence.by_month_day entries must be integers 1..31");
+  }
 }
-function normalizePositiveInteger(value) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : void 0;
+function assertRecurrenceExdates(value) {
+  if (value === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(Array.isArray(value), "event.recurrence.exdates must be an array");
+  for (const exdate of value) {
+    assertItemMetadataCondition(typeof exdate === "string", "event.recurrence.exdates entries must be strings");
+    assertItemMetadataCondition(isTimestampLiteral(exdate), "event.recurrence.exdates entries must be valid ISO timestamps");
+  }
 }
-function stringOrEmpty(value) {
-  return typeof value === "string" ? value : "";
+function assertValidRecurrenceRule(recurrence) {
+  assertItemMetadataCondition(typeof recurrence === "object" && recurrence !== null && !Array.isArray(recurrence), "event.recurrence must be an object");
+  const recurrenceRecord = recurrence;
+  assertItemMetadataCondition(typeof recurrenceRecord.freq === "string", "event.recurrence.freq must be a string");
+  const frequency = recurrenceRecord.freq.trim().toLowerCase();
+  assertItemMetadataCondition(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 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 assertRequiredItemMetadataFields(record) {
+  for (const fieldName of REQUIRED_STRING_FIELDS) {
+    assertItemMetadataCondition(typeof record[fieldName] === "string", `${fieldName} is required and must be a string`);
+  }
+  const itemType = record.type;
+  assertItemMetadataCondition(typeof itemType === "string" && itemType.trim().length > 0, "type must be a non-empty string");
+  const formatVersion = record.pm_format_version;
+  if (formatVersion !== void 0) {
+    assertItemMetadataCondition(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 sortTests(values) {
-  if (!Array.isArray(values) || values.length === 0)
-    return void 0;
-  return [...values].map(normalizeLinkedTest).sort(compareLinkedTests);
+function assertStatusItemMetadataField(record, runtimeContext) {
+  const status = record.status;
+  assertItemMetadataCondition(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];
+  assertItemMetadataCondition(normalizedStatus !== void 0, `status must be one of: ${statusDomain.join(", ")}`);
 }
-function normalizeTrimmedStringList(value) {
-  if (!Array.isArray(value)) {
-    return void 0;
+function assertPriorityAndTags(record) {
+  const priority = record.priority;
+  assertItemMetadataCondition(typeof priority === "number" && Number.isInteger(priority) && [0, 1, 2, 3, 4].includes(priority), "priority must be an integer 0..4");
+  const tags = record.tags;
+  assertItemMetadataCondition(Array.isArray(tags), "tags must be an array");
+  for (const tag of tags) {
+    assertItemMetadataCondition(typeof tag === "string", "tags entries must be strings");
   }
-  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;
+function assertConfidenceItemMetadataField(record) {
+  const confidence = record.confidence;
+  if (confidence === void 0) {
+    return;
   }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+  if (typeof confidence === "number") {
+    assertItemMetadataCondition(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);
+    assertItemMetadataCondition(isKnownTextConfidence, `confidence string value must be one of: ${[...CONFIDENCE_TEXT_VALUES, "med"].join(", ")}`);
+    return;
+  }
+  assertItemMetadataCondition(false, "confidence must be a number or string");
 }
-function isUnsafeObjectKey(key) {
-  return key === "__proto__" || key === "constructor" || key === "prototype";
+function assertSeverityItemMetadataField(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);
+  assertItemMetadataCondition(isKnownSeverity, `severity value must be one of: ${[...ISSUE_SEVERITY_VALUES, "med"].join(", ")}`);
 }
-function normalizeStringRecord(value) {
-  if (!isPlainObjectRecord(value)) {
-    return void 0;
+function assertRegressionItemMetadataField(record) {
+  if (record.regression !== void 0 && typeof record.regression !== "boolean") {
+    validationError("regression must be a boolean");
   }
-  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;
+function assertReminderEntries(record) {
+  const reminders = record.reminders;
+  if (reminders === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(Array.isArray(reminders), "reminders must be an array");
+  for (const reminder of reminders) {
+    assertItemMetadataCondition(typeof reminder === "object" && reminder !== null && !Array.isArray(reminder), "reminders entries must be objects");
+    const reminderRecord = reminder;
+    assertItemMetadataCondition(typeof reminderRecord.at === "string", "reminder.at must be a string");
+    assertItemMetadataCondition(isTimestampLiteral(reminderRecord.at), "reminder.at must be a valid ISO timestamp");
+    assertItemMetadataCondition(typeof reminderRecord.text === "string", "reminder.text must be a string");
+    assertItemMetadataCondition(reminderRecord.text.trim().length > 0, "reminder.text must not be empty");
   }
-  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;
+function assertEventStringFields(eventRecord) {
+  for (const stringField of [
+    "title",
+    "description",
+    "location",
+    "timezone"
+  ]) {
+    if (eventRecord[stringField] !== void 0) {
+      assertItemMetadataCondition(typeof eventRecord[stringField] === "string", `event.${stringField} must be a string`);
+      assertItemMetadataCondition(eventRecord[stringField].trim().length > 0, `event.${stringField} must not be empty`);
+    }
   }
-  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 assertEventRecurrence(eventRecord) {
+  if (eventRecord.recurrence === void 0) {
+    return;
+  }
+  assertValidRecurrenceRule(eventRecord.recurrence);
+  if (eventRecord.recurrence.until !== void 0) {
+    assertItemMetadataCondition(compareTimestampStrings(eventRecord.recurrence.until, eventRecord.start_at) >= 0, "event.recurrence.until must be at or after event.start_at");
+  }
 }
-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 assertCalendarEventEntry(event) {
+  assertItemMetadataCondition(typeof event === "object" && event !== null && !Array.isArray(event), "events entries must be objects");
+  const eventRecord = event;
+  assertItemMetadataCondition(typeof eventRecord.start_at === "string", "event.start_at must be a string");
+  assertItemMetadataCondition(isTimestampLiteral(eventRecord.start_at), "event.start_at must be a valid ISO timestamp");
+  if (eventRecord.end_at !== void 0) {
+    assertItemMetadataCondition(typeof eventRecord.end_at === "string", "event.end_at must be a string");
+    assertItemMetadataCondition(isTimestampLiteral(eventRecord.end_at), "event.end_at must be a valid ISO timestamp");
+    assertItemMetadataCondition(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) {
+    assertItemMetadataCondition(typeof eventRecord.all_day === "boolean", "event.all_day must be a boolean");
+  }
+  assertEventRecurrence(eventRecord);
 }
-function compareOptionalStrings(left, right) {
-  return (left ?? "").localeCompare(right ?? "");
+function assertCalendarEvents(record) {
+  const events = record.events;
+  if (events === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(Array.isArray(events), "events must be an array");
+  for (const event of events) {
+    assertCalendarEventEntry(event);
+  }
 }
-function compareOptionalNumbers(left, right) {
-  return (left ?? 0) - (right ?? 0);
+function assertOptionalStringFields(record) {
+  for (const fieldName of [
+    "source_type",
+    "source_owner",
+    "design",
+    "external_ref"
+  ]) {
+    const value = record[fieldName];
+    if (value !== void 0) {
+      assertItemMetadataCondition(typeof value === "string", `${fieldName} must be a string`);
+    }
+  }
 }
-function compareJsonValues(left, right, fallback) {
-  return JSON.stringify(left ?? fallback).localeCompare(JSON.stringify(right ?? fallback));
+function assertTypeOptionsField(record) {
+  const typeOptions = record.type_options;
+  if (typeOptions === void 0) {
+    return;
+  }
+  assertItemMetadataCondition(typeof typeOptions === "object" && typeOptions !== null && !Array.isArray(typeOptions), "type_options must be an object");
+  for (const [optionKey, optionValue] of Object.entries(typeOptions)) {
+    assertItemMetadataCondition(optionKey.trim().length > 0, "type_options keys must be non-empty");
+    assertItemMetadataCondition(typeof optionValue === "string", "type_options values must be strings");
+    const optionText = optionValue;
+    assertItemMetadataCondition(optionText.trim().length > 0, "type_options values must be non-empty strings");
+  }
 }
-function sortDocs(values) {
+function coerceRuntimeItemMetadataFields(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 assertRuntimeUnknownItemMetadataFields(record, runtimeContext) {
+  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
+    return;
+  }
+  const knownKeys = buildKnownItemMetadataKeys(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 assertValidItemMetadata(itemMetadata, runtimeContext) {
+  assertItemMetadataCondition(typeof itemMetadata === "object" && itemMetadata !== null && !Array.isArray(itemMetadata), "item metadata must be an object");
+  const record = itemMetadata;
+  const itemType = assertRequiredItemMetadataFields(record);
+  assertStatusItemMetadataField(record, runtimeContext);
+  assertPriorityAndTags(record);
+  assertConfidenceItemMetadataField(record);
+  assertSeverityItemMetadataField(record);
+  assertRegressionItemMetadataField(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);
+  coerceRuntimeItemMetadataFields(record, itemType, runtimeContext);
+  assertRuntimeUnknownItemMetadataFields(record, runtimeContext);
+}
+function sortDependencies(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
+    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 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 ?? "");
+    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 trimStringOrUndefined(value) {
-  if (typeof value !== "string")
+function sortLogValues(values) {
+  if (!values || values.length === 0)
     return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : 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 normalizePlanStepLinks(value) {
-  if (!Array.isArray(value))
+function sortReminders(values) {
+  if (!values || values.length === 0)
     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;
+  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 normalizePlanStepFiles(value) {
-  if (!Array.isArray(value))
+function normalizeRecurrenceRule(value) {
+  if (!value) {
     return void 0;
-  const out = [];
-  for (const entry of value) {
-    if (entry === null || typeof entry !== "object")
-      continue;
-    const record = entry;
-    const path6 = trimStringOrUndefined(record.path);
-    if (!path6)
-      continue;
-    const file = { path: normalizePathValue(path6) };
-    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))
+  const normalizedFrequency = value.freq.trim().toLowerCase();
+  if (!RECURRENCE_FREQUENCY_VALUES.includes(normalizedFrequency)) {
     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 path6 = trimStringOrUndefined(record.path);
-    if (!command && !path6)
-      continue;
-    const test = {};
-    if (command)
-      test.command = command;
-    if (path6)
-      test.path = normalizePathValue(path6);
-    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 path6 = trimStringOrUndefined(record.path);
-    if (!path6)
-      continue;
-    const doc = { path: normalizePathValue(path6) };
-    if (record.scope === "project" || record.scope === "global")
-      doc.scope = record.scope;
-    const note = trimStringOrUndefined(record.note);
-    if (note)
-      doc.note = note;
-    out.push(doc);
+  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 out.length > 0 ? out : void 0;
+  return normalized;
 }
-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 order = coerceFiniteNumber(record.order) ?? 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) {
+function sortEvents(values) {
+  if (!Array.isArray(values) || values.length === 0) {
     return void 0;
   }
-  const step = {
-    id,
-    order,
-    title,
-    status,
-    created_at,
-    updated_at
+  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)
   };
-  applyPlanStepOptionalFields(step, record);
-  return step;
+  deleteUndefinedFields(event);
+  return event;
 }
-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 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 normalizePlanSteps(value) {
-  if (!Array.isArray(value))
+function normalizeFiles(values) {
+  if (!values || values.length === 0)
     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;
+  return values.map((value) => ({
+    path: normalizePathValue(value.path),
+    scope: value.scope,
+    note: value.note?.trim() || void 0
+  }));
 }
-function normalizePlanDecisions(value) {
-  if (!Array.isArray(value))
+function normalizeTestRunSummaries(values) {
+  if (!values || values.length === 0)
     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;
+  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 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 normalizeNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 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 normalizePositiveInteger(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : void 0;
 }
-function normalizeTypeOptions(values) {
-  if (!values) {
+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;
-  }
-  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 [...values].map(normalizeLinkedTest).sort(compareLinkedTests);
+}
+function normalizeTrimmedStringList(value) {
+  if (!Array.isArray(value)) {
     return void 0;
   }
-  return Object.fromEntries(normalizedEntries);
+  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 normalizeBody(body) {
-  let start = 0;
-  while (start < body.length && body[start] === "\n") {
-    start += 1;
+function isPlainObjectRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
   }
-  return body.slice(start).trimEnd();
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
 }
-function normalizeConfidenceValue(value) {
-  if (value === void 0) {
+function isUnsafeObjectKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function normalizeStringRecord(value) {
+  if (!isPlainObjectRecord(value)) {
     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;
+  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 normalizeSeverityValue(value) {
-  if (value === void 0) {
+function normalizeNumericRecord(value) {
+  if (!isPlainObjectRecord(value)) {
     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;
+  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 copyExtensionItemMetadataFields(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 normalizeLinkedTestContextMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized || !LINKED_TEST_PM_CONTEXT_MODE_VALUES.has(normalized)) {
+    return void 0;
   }
+  return normalized;
 }
-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) {
+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;
-    }
-    record[definition.metadata_key] = coerceRuntimeFieldValue(definition, currentValue, `metadata field "${definition.metadata_key}"`);
+    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 assertNormalizedUnknownFields(normalized, runtimeContext) {
-  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
-    return;
-  }
-  const knownKeys = buildKnownItemMetadataKeys(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 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 path6 = trimStringOrUndefined(record.path);
+    if (!path6)
+      continue;
+    const file = { path: normalizePathValue(path6) };
+    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 normalizeItemMetadata(itemMetadata, options = {}) {
-  const runtimeContext = resolveRuntimeSchemaValidationContext(options);
-  const normalizedStatus = normalizeStatusInput(itemMetadata.status, runtimeContext?.statusRegistry) ?? itemMetadata.status;
-  const tags = Array.from(new Set(itemMetadata.tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean))).sort((a, b) => a.localeCompare(b));
-  const normalized = {
-    id: itemMetadata.id,
-    title: itemMetadata.title,
-    description: itemMetadata.description,
-    type: itemMetadata.type,
-    pm_format_version: normalizeItemFormatVersion(itemMetadata.pm_format_version),
-    source_type: trimStringOrUndefined(itemMetadata.source_type),
-    type_options: normalizeTypeOptions(itemMetadata.type_options),
-    status: normalizedStatus,
-    priority: itemMetadata.priority,
-    tags,
-    created_at: itemMetadata.created_at,
-    updated_at: itemMetadata.updated_at,
-    dependencies: sortDependencies(itemMetadata.dependencies),
-    comments: sortLogValues(itemMetadata.comments),
-    notes: sortLogValues(itemMetadata.notes),
-    learnings: sortLogValues(itemMetadata.learnings),
-    files: normalizeFiles(itemMetadata.files),
-    tests: sortTests(itemMetadata.tests),
-    test_runs: normalizeTestRunSummaries(itemMetadata.test_runs),
-    docs: sortDocs(itemMetadata.docs),
-    deadline: emptyStringToUndefined(itemMetadata.deadline),
-    reminders: sortReminders(itemMetadata.reminders),
-    events: sortEvents(itemMetadata.events),
-    closed_at: emptyStringToUndefined(itemMetadata.closed_at),
-    assignee: trimStringOrUndefined(itemMetadata.assignee),
-    source_owner: trimStringOrUndefined(itemMetadata.source_owner),
-    author: emptyStringToUndefined(itemMetadata.author),
-    estimated_minutes: itemMetadata.estimated_minutes,
-    acceptance_criteria: itemMetadata.acceptance_criteria ?? void 0,
-    design: itemMetadata.design ?? void 0,
-    external_ref: itemMetadata.external_ref ?? void 0,
-    definition_of_ready: trimStringOrUndefined(itemMetadata.definition_of_ready),
-    order: itemMetadata.order,
-    goal: trimStringOrUndefined(itemMetadata.goal),
-    objective: trimStringOrUndefined(itemMetadata.objective),
-    value: trimStringOrUndefined(itemMetadata.value),
-    impact: trimStringOrUndefined(itemMetadata.impact),
-    outcome: trimStringOrUndefined(itemMetadata.outcome),
-    why_now: trimStringOrUndefined(itemMetadata.why_now),
-    parent: trimStringOrUndefined(itemMetadata.parent),
-    reviewer: trimStringOrUndefined(itemMetadata.reviewer),
-    risk: itemMetadata.risk ?? void 0,
-    confidence: normalizeConfidenceValue(itemMetadata.confidence),
-    sprint: trimStringOrUndefined(itemMetadata.sprint),
-    release: trimStringOrUndefined(itemMetadata.release),
-    blocked_by: trimStringOrUndefined(itemMetadata.blocked_by),
-    blocked_reason: trimStringOrUndefined(itemMetadata.blocked_reason),
-    unblock_note: trimStringOrUndefined(itemMetadata.unblock_note),
-    reporter: trimStringOrUndefined(itemMetadata.reporter),
-    severity: normalizeSeverityValue(itemMetadata.severity),
-    environment: trimStringOrUndefined(itemMetadata.environment),
-    repro_steps: trimStringOrUndefined(itemMetadata.repro_steps),
-    resolution: trimStringOrUndefined(itemMetadata.resolution),
-    expected_result: trimStringOrUndefined(itemMetadata.expected_result),
-    actual_result: trimStringOrUndefined(itemMetadata.actual_result),
-    affected_version: trimStringOrUndefined(itemMetadata.affected_version),
-    fixed_version: trimStringOrUndefined(itemMetadata.fixed_version),
-    component: trimStringOrUndefined(itemMetadata.component),
-    regression: itemMetadata.regression,
-    customer_impact: trimStringOrUndefined(itemMetadata.customer_impact),
-    close_reason: emptyStringToUndefined(itemMetadata.close_reason),
-    plan_mode: trimStringOrUndefined(itemMetadata.plan_mode),
-    plan_scope: trimStringOrUndefined(itemMetadata.plan_scope),
-    plan_harness: trimStringOrUndefined(itemMetadata.plan_harness),
-    plan_resume_context: trimStringOrUndefined(itemMetadata.plan_resume_context),
-    plan_steps: normalizePlanSteps(itemMetadata.plan_steps),
-    plan_decisions: normalizePlanDecisions(itemMetadata.plan_decisions),
-    plan_discoveries: normalizePlanDiscoveries(itemMetadata.plan_discoveries),
-    plan_validation: normalizePlanValidation(itemMetadata.plan_validation)
-  };
-  copyExtensionItemMetadataFields(normalized, itemMetadata);
-  coerceNormalizedRuntimeFields(normalized, runtimeContext);
-  assertNormalizedUnknownFields(normalized, runtimeContext);
-  deleteUndefinedFields(normalized);
-  return normalized;
-}
-function orderItemMetadata(itemMetadata) {
-  return orderObject(itemMetadata, ITEM_METADATA_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;
-      }
+function normalizePlanStepTests(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  const out = [];
+  for (const entry of value) {
+    if (entry === null || typeof entry !== "object")
       continue;
-    }
-    if (char === '"') {
-      inString = true;
+    const record = entry;
+    const command = trimStringOrUndefined(record.command);
+    const path6 = trimStringOrUndefined(record.path);
+    if (!command && !path6)
+      continue;
+    const test = {};
+    if (command)
+      test.command = command;
+    if (path6)
+      test.path = normalizePathValue(path6);
+    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;
-    }
-    if (char === "{") {
-      depth += 1;
+    const record = entry;
+    const path6 = trimStringOrUndefined(record.path);
+    if (!path6)
       continue;
-    }
-    if (char === "}") {
-      depth -= 1;
-      if (depth === 0) {
-        return i;
-      }
-    }
+    const doc = { path: normalizePathValue(path6) };
+    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 -1;
+  return out.length > 0 ? out : void 0;
 }
-function splitFrontMatter(content) {
-  if (!content.startsWith("{")) {
-    return { frontMatter: "", body: content };
+function normalizePlanStepEntry(entry) {
+  if (entry === null || typeof entry !== "object") {
+    return void 0;
   }
-  const end = findJsonObjectEnd(content);
-  if (end < 0) {
-    return { frontMatter: "", body: content };
+  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 order = coerceFiniteNumber(record.order) ?? 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 frontMatter = content.slice(0, end + 1);
-  const body = content.slice(end + 1).replace(/^\r?\n+/, "");
-  return { frontMatter, body };
+  const step = {
+    id,
+    order,
+    title,
+    status,
+    created_at,
+    updated_at
+  };
+  applyPlanStepOptionalFields(step, record);
+  return step;
 }
-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
-      };
+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;
     }
-    cursor = afterLine;
   }
-  return { content: normalizedContent, stripped: false };
-}
-function normalizeParsedItemMetadata(itemMetadata, options) {
-  return normalizeItemMetadata(itemMetadata, {
-    ...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 completedAt = typeof record.completed_at === "string" ? record.completed_at : void 0;
+  if (completedAt && completedAt.length > 0) {
+    step.completed_at = completedAt;
   }
-  const { frontMatter, body } = splitFrontMatter(normalized.content);
-  if (!frontMatter) {
-    const trimmed = content.trimStart();
-    if (trimmed.startsWith("{")) {
-      validationError("JSON front matter is not valid JSON");
+  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;
     }
-    validationError("missing JSON front matter");
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(frontMatter);
-  } catch {
-    validationError("JSON front matter is not valid JSON");
   }
-  assertValidItemMetadata(parsed, runtimeContext);
-  return {
-    metadata: normalizeParsedItemMetadata(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");
-  }
-  assertItemMetadataCondition(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")) {
-    assertValidItemMetadata(record.front_matter, runtimeContext);
-    assertItemMetadataCondition(record.body === void 0 || typeof record.body === "string", "TOON item document body must be a string");
-    return {
-      metadata: normalizeParsedItemMetadata(record.front_matter, options),
-      body: normalizeBody(typeof record.body === "string" ? record.body : "")
-    };
-  }
-  const { body, ...itemMetadataRecord } = record;
-  assertItemMetadataCondition(body === void 0 || typeof body === "string", "TOON item document body must be a string");
-  assertValidItemMetadata(itemMetadataRecord, runtimeContext);
-  return {
-    metadata: normalizeParsedItemMetadata(itemMetadataRecord, options),
-    body: normalizeBody(typeof body === "string" ? body : "")
-  };
+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 serializeJsonMarkdownItemDocument(document, options = {}) {
-  const normalizedMetadata = normalizeItemMetadata(document.metadata, options);
-  const orderedMetadata = orderItemMetadata(normalizedMetadata);
-  const serializedMetadata = JSON.stringify(orderedMetadata, null, 2);
-  const normalizedBody = normalizeBody(document.body ?? "");
-  if (!normalizedBody) {
-    return `${serializedMetadata}
-`;
+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 `${serializedMetadata}
-
-${normalizedBody}
-`;
+  return out.length > 0 ? out : void 0;
 }
-function serializeToonItemDocument(document, options = {}) {
-  const normalizedMetadata = normalizeItemMetadata(document.metadata, options);
-  const orderedMetadata = orderItemMetadata(normalizedMetadata);
-  const normalizedBody = normalizeBody(document.body ?? "");
-  return `${encodeToon({ ...orderedMetadata, body: normalizedBody })}
-`;
+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 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."
-      ]
-    });
+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);
   }
-  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);
+  return out.length > 0 ? out : void 0;
 }
-function canonicalDocument(document, options = {}) {
-  return {
-    metadata: normalizeItemMetadata(document.metadata, options),
-    body: normalizeBody(document.body ?? "")
-  };
+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);
 }
-
-// dist/core/item/item-record.js
-function toItemRecord(item) {
-  return item;
+function normalizeBody(body) {
+  let start = 0;
+  while (start < body.length && body[start] === "\n") {
+    start += 1;
+  }
+  return body.slice(start).trimEnd();
 }
-
-// dist/core/history/history.js
-import jsonPatch from "fast-json-patch";
-var EMPTY_LEGACY_HASH_DOCUMENT = {
-  front_matter: {},
-  body: ""
-};
-function decodeJsonPointer(path6) {
-  if (!path6 || path6 === "/") {
-    return [];
+function normalizeConfidenceValue(value) {
+  if (value === void 0) {
+    return void 0;
   }
-  if (!path6.startsWith("/")) {
-    return [];
+  if (typeof value === "number") {
+    return value;
   }
-  return path6.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "med") {
+    return "medium";
+  }
+  if (CONFIDENCE_TEXT_VALUES.includes(normalized)) {
+    return normalized;
+  }
+  return void 0;
 }
-function isDefinedPointerPath(document, path6) {
-  const segments = decodeJsonPointer(path6);
-  if (segments.length === 0) {
-    return true;
+function normalizeSeverityValue(value) {
+  if (value === void 0) {
+    return void 0;
   }
-  let cursor = document;
-  for (const segment of segments) {
-    if (Array.isArray(cursor)) {
-      if (segment === "-" || !/^(0|[1-9]\d*)$/.test(segment)) {
-        return false;
-      }
-      const index = Number(segment);
-      if (!Number.isInteger(index) || index < 0 || index >= cursor.length) {
-        return false;
-      }
-      const next2 = cursor[index];
-      if (next2 === void 0) {
-        return false;
-      }
-      cursor = next2;
+  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 copyExtensionItemMetadataFields(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;
     }
-    if (typeof cursor !== "object" || cursor === null) {
-      return false;
-    }
-    if (!Object.prototype.hasOwnProperty.call(cursor, segment)) {
-      return false;
-    }
-    const next = cursor[segment];
-    if (next === void 0) {
-      return false;
-    }
-    cursor = next;
+    targetRecord[key] = value;
   }
-  return true;
 }
-function normalizeHistoryPatchOps(beforeDocument, patch) {
-  const normalized = [];
-  let replayCursor = structuredClone(beforeDocument);
-  for (const operation of patch) {
-    const normalizedOperation = operation.op === "replace" && !isDefinedPointerPath(replayCursor, operation.path) ? { ...operation, op: "add" } : operation;
-    normalized.push(normalizedOperation);
-    replayCursor = jsonPatch.applyPatch(replayCursor, [normalizedOperation], true, true).newDocument;
+function coerceNormalizedRuntimeFields(normalized, runtimeContext) {
+  if (!runtimeContext?.fieldRegistry) {
+    return;
   }
-  return normalized;
-}
-function canonicalHashDocument(document) {
-  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
-  if (!hasMetadata) {
-    return {
-      front_matter: {},
-      body: document.body ?? ""
-    };
+  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}"`);
   }
-  const canonical = canonicalDocument(document);
-  const orderedMetadata = orderObject(toItemRecord(canonical.metadata), ITEM_METADATA_KEY_ORDER);
-  return {
-    front_matter: orderedMetadata,
-    body: canonical.body
-  };
 }
-function canonicalPatchDocument(document) {
-  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
-  if (!hasMetadata) {
-    return {
-      metadata: {},
-      body: document.body ?? ""
-    };
+function assertNormalizedUnknownFields(normalized, runtimeContext) {
+  if (!runtimeContext || runtimeContext.unknownFieldPolicy === "allow") {
+    return;
+  }
+  const knownKeys = buildKnownItemMetadataKeys(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(",")}`);
   }
-  const canonical = canonicalDocument(document);
-  const orderedMetadata = orderObject(toItemRecord(canonical.metadata), ITEM_METADATA_KEY_ORDER);
-  return {
-    metadata: orderedMetadata,
-    body: canonical.body
-  };
-}
-function hashDocument(document) {
-  return sha256Hex(stableStringify(canonicalHashDocument(document)));
-}
-function hashEmptyDocument() {
-  return sha256Hex(stableStringify(EMPTY_LEGACY_HASH_DOCUMENT));
 }
-function createHistoryEntry(params) {
-  const beforeHashCanonical = canonicalHashDocument(params.before);
-  const afterHashCanonical = canonicalHashDocument(params.after);
-  const beforePatchCanonical = canonicalPatchDocument(params.before);
-  const afterPatchCanonical = canonicalPatchDocument(params.after);
-  const rawPatch = jsonPatch.compare(beforePatchCanonical, afterPatchCanonical);
-  const patch = normalizeHistoryPatchOps(beforePatchCanonical, rawPatch);
-  return {
-    ts: params.nowIso,
-    author: params.author,
-    op: params.op,
-    patch,
-    before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
-    after_hash: sha256Hex(stableStringify(afterHashCanonical)),
-    message: params.message === void 0 ? void 0 : params.message
+function normalizeItemMetadata(itemMetadata, options = {}) {
+  const runtimeContext = resolveRuntimeSchemaValidationContext(options);
+  const normalizedStatus = normalizeStatusInput(itemMetadata.status, runtimeContext?.statusRegistry) ?? itemMetadata.status;
+  const tags = Array.from(new Set(itemMetadata.tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean))).sort((a, b) => a.localeCompare(b));
+  const normalized = {
+    id: itemMetadata.id,
+    title: itemMetadata.title,
+    description: itemMetadata.description,
+    type: itemMetadata.type,
+    pm_format_version: normalizeItemFormatVersion(itemMetadata.pm_format_version),
+    source_type: trimStringOrUndefined(itemMetadata.source_type),
+    type_options: normalizeTypeOptions(itemMetadata.type_options),
+    status: normalizedStatus,
+    priority: itemMetadata.priority,
+    tags,
+    created_at: itemMetadata.created_at,
+    updated_at: itemMetadata.updated_at,
+    dependencies: sortDependencies(itemMetadata.dependencies),
+    comments: sortLogValues(itemMetadata.comments),
+    notes: sortLogValues(itemMetadata.notes),
+    learnings: sortLogValues(itemMetadata.learnings),
+    files: normalizeFiles(itemMetadata.files),
+    tests: sortTests(itemMetadata.tests),
+    test_runs: normalizeTestRunSummaries(itemMetadata.test_runs),
+    docs: sortDocs(itemMetadata.docs),
+    deadline: emptyStringToUndefined(itemMetadata.deadline),
+    reminders: sortReminders(itemMetadata.reminders),
+    events: sortEvents(itemMetadata.events),
+    closed_at: emptyStringToUndefined(itemMetadata.closed_at),
+    assignee: trimStringOrUndefined(itemMetadata.assignee),
+    source_owner: trimStringOrUndefined(itemMetadata.source_owner),
+    author: emptyStringToUndefined(itemMetadata.author),
+    estimated_minutes: itemMetadata.estimated_minutes,
+    acceptance_criteria: itemMetadata.acceptance_criteria ?? void 0,
+    design: itemMetadata.design ?? void 0,
+    external_ref: itemMetadata.external_ref ?? void 0,
+    definition_of_ready: trimStringOrUndefined(itemMetadata.definition_of_ready),
+    order: itemMetadata.order,
+    goal: trimStringOrUndefined(itemMetadata.goal),
+    objective: trimStringOrUndefined(itemMetadata.objective),
+    value: trimStringOrUndefined(itemMetadata.value),
+    impact: trimStringOrUndefined(itemMetadata.impact),
+    outcome: trimStringOrUndefined(itemMetadata.outcome),
+    why_now: trimStringOrUndefined(itemMetadata.why_now),
+    parent: trimStringOrUndefined(itemMetadata.parent),
+    reviewer: trimStringOrUndefined(itemMetadata.reviewer),
+    risk: itemMetadata.risk ?? void 0,
+    confidence: normalizeConfidenceValue(itemMetadata.confidence),
+    sprint: trimStringOrUndefined(itemMetadata.sprint),
+    release: trimStringOrUndefined(itemMetadata.release),
+    blocked_by: trimStringOrUndefined(itemMetadata.blocked_by),
+    blocked_reason: trimStringOrUndefined(itemMetadata.blocked_reason),
+    unblock_note: trimStringOrUndefined(itemMetadata.unblock_note),
+    reporter: trimStringOrUndefined(itemMetadata.reporter),
+    severity: normalizeSeverityValue(itemMetadata.severity),
+    environment: trimStringOrUndefined(itemMetadata.environment),
+    repro_steps: trimStringOrUndefined(itemMetadata.repro_steps),
+    resolution: trimStringOrUndefined(itemMetadata.resolution),
+    expected_result: trimStringOrUndefined(itemMetadata.expected_result),
+    actual_result: trimStringOrUndefined(itemMetadata.actual_result),
+    affected_version: trimStringOrUndefined(itemMetadata.affected_version),
+    fixed_version: trimStringOrUndefined(itemMetadata.fixed_version),
+    component: trimStringOrUndefined(itemMetadata.component),
+    regression: itemMetadata.regression,
+    customer_impact: trimStringOrUndefined(itemMetadata.customer_impact),
+    close_reason: emptyStringToUndefined(itemMetadata.close_reason),
+    plan_mode: trimStringOrUndefined(itemMetadata.plan_mode),
+    plan_scope: trimStringOrUndefined(itemMetadata.plan_scope),
+    plan_harness: trimStringOrUndefined(itemMetadata.plan_harness),
+    plan_resume_context: trimStringOrUndefined(itemMetadata.plan_resume_context),
+    plan_steps: normalizePlanSteps(itemMetadata.plan_steps),
+    plan_decisions: normalizePlanDecisions(itemMetadata.plan_decisions),
+    plan_discoveries: normalizePlanDiscoveries(itemMetadata.plan_discoveries),
+    plan_validation: normalizePlanValidation(itemMetadata.plan_validation)
   };
+  copyExtensionItemMetadataFields(normalized, itemMetadata);
+  coerceNormalizedRuntimeFields(normalized, runtimeContext);
+  assertNormalizedUnknownFields(normalized, runtimeContext);
+  deleteUndefinedFields(normalized);
+  return normalized;
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function fallbackHistoryTimestamp(entry) {
-  const ts = entry.ts.trim();
-  return ts.length > 0 ? ts : nowIso();
-}
-function withHistoryTimestamp(value, fallbackTs) {
-  const ts = value.ts;
-  if (typeof ts === "string" && ts.trim().length > 0) {
-    return value;
-  }
-  return { ...value, ts: fallbackTs };
+function orderItemMetadata(itemMetadata) {
+  return orderObject(itemMetadata, ITEM_METADATA_KEY_ORDER);
 }
-function serializeHistoryLine(value, fallbackEntry) {
-  const fallbackTs = fallbackHistoryTimestamp(fallbackEntry);
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      if (isRecord(parsed)) {
-        return JSON.stringify(withHistoryTimestamp(parsed, fallbackTs));
+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;
       }
-    } catch {
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === '"') {
+        inString = false;
+      }
+      continue;
     }
-    return value;
-  }
-  if (isRecord(value)) {
-    return JSON.stringify(withHistoryTimestamp(value, fallbackTs));
-  }
-  return JSON.stringify(value);
-}
-async function appendHistoryEntry(historyPath, entry) {
-  const override = await runActiveServiceOverride("history_append", {
-    history_path: historyPath,
-    entry
-  });
-  if (override.handled) {
-    if (override.result === false) {
-      return;
+    if (char === '"') {
+      inString = true;
+      continue;
     }
-    if (typeof override.result === "string") {
-      await appendLineAtomic(historyPath, serializeHistoryLine(override.result, entry));
-      return;
+    if (char === "{") {
+      depth += 1;
+      continue;
     }
-    if (typeof override.result === "object" && override.result !== null) {
-      const record = override.result;
-      if (record.skip === true) {
-        return;
-      }
-      const nextHistoryPath = typeof record.history_path === "string" ? record.history_path : historyPath;
-      if (typeof record.line === "string") {
-        await appendLineAtomic(nextHistoryPath, serializeHistoryLine(record.line, entry));
-        return;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
       }
-      await appendLineAtomic(nextHistoryPath, serializeHistoryLine(record.entry ?? entry, entry));
-      return;
     }
   }
-  await appendLineAtomic(historyPath, serializeHistoryLine(entry, entry));
-}
-
-// dist/core/history/history-stream-policy.js
-import fs from "node:fs/promises";
-import path from "node:path";
-function toSortedUniqueItemIds(itemIds) {
-  return [...new Set(itemIds.filter((value) => value.trim().length > 0))].sort((left, right) => left.localeCompare(right));
+  return -1;
 }
-function strictMissingStreamError(itemId, commandLabel) {
-  return new PmCliError(`Missing history stream for ${itemId}. ${commandLabel} requires history streams when settings.history.missing_stream is strict_error.`, EXIT_CODE.NOT_FOUND);
+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 };
 }
-async function createStream(historyPath, commandLabel) {
-  await ensureDir(path.dirname(historyPath));
-  const handle = await fs.open(historyPath, "a");
-  await handle.close();
-  return runActiveOnWriteHooks({
-    path: historyPath,
-    scope: "project",
-    op: `${commandLabel}:history:auto_create`
-  });
+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 };
 }
-async function enforceHistoryStreamPolicyForItem(params) {
-  return enforceHistoryStreamPolicyForItems({
-    pmRoot: params.pmRoot,
-    settings: params.settings,
-    itemIds: [params.itemId],
-    commandLabel: params.commandLabel
+function normalizeParsedItemMetadata(itemMetadata, options) {
+  return normalizeItemMetadata(itemMetadata, {
+    ...options,
+    onWarning: void 0
   });
 }
-async function enforceHistoryStreamPolicyForItems(params) {
-  const ids = toSortedUniqueItemIds(params.itemIds);
-  const autoCreated = [];
-  const warnings = [];
-  for (const itemId of ids) {
-    const historyPath = getHistoryPath(params.pmRoot, itemId);
-    if (await pathExists(historyPath)) {
-      continue;
-    }
-    if (params.settings.history.missing_stream === "strict_error") {
-      throw strictMissingStreamError(itemId, params.commandLabel);
+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");
     }
-    warnings.push(...await createStream(historyPath, params.commandLabel));
-    warnings.push(`history_stream_auto_created:${itemId}`);
-    autoCreated.push(itemId);
+    validationError("missing JSON front matter");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(frontMatter);
+  } catch {
+    validationError("JSON front matter is not valid JSON");
   }
+  assertValidItemMetadata(parsed, runtimeContext);
   return {
-    auto_created_ids: autoCreated,
-    warnings
+    metadata: normalizeParsedItemMetadata(parsed, options),
+    body: normalizeBody(body)
   };
 }
-
-// dist/core/lock/lock.js
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-import { randomUUID } from "node:crypto";
-function parseLockInfo(raw) {
+function parseToonItemDocument(content, runtimeContext, options = {}) {
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = decodeToonItemContent(content).value;
   } catch {
-    return {
-      info: null,
-      warnings: ["lock_info_invalid_json"]
-    };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return {
-      info: null,
-      warnings: ["lock_info_invalid_shape"]
-    };
+    validationError("TOON item document is not valid TOON");
   }
-  const candidate = parsed;
-  const id = candidate.id;
-  const pid = candidate.pid;
-  const owner = candidate.owner;
-  const createdAt = candidate.created_at;
-  const ttlSeconds = candidate.ttl_seconds;
-  if (typeof id !== "string" || typeof pid !== "number" || !Number.isFinite(pid) || typeof owner !== "string" || typeof createdAt !== "string" || typeof ttlSeconds !== "number" || !Number.isFinite(ttlSeconds)) {
+  assertItemMetadataCondition(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")) {
+    assertValidItemMetadata(record.front_matter, runtimeContext);
+    assertItemMetadataCondition(record.body === void 0 || typeof record.body === "string", "TOON item document body must be a string");
     return {
-      info: null,
-      warnings: ["lock_info_invalid_shape"]
+      metadata: normalizeParsedItemMetadata(record.front_matter, options),
+      body: normalizeBody(typeof record.body === "string" ? record.body : "")
     };
   }
+  const { body, ...itemMetadataRecord } = record;
+  assertItemMetadataCondition(body === void 0 || typeof body === "string", "TOON item document body must be a string");
+  assertValidItemMetadata(itemMetadataRecord, runtimeContext);
   return {
-    info: {
-      id,
-      pid,
-      owner,
-      created_at: createdAt,
-      ttl_seconds: ttlSeconds
-    },
-    warnings: []
+    metadata: normalizeParsedItemMetadata(itemMetadataRecord, options),
+    body: normalizeBody(typeof body === "string" ? body : "")
   };
 }
-async function readLockInfo(lockPath) {
-  try {
-    const raw = await fs2.readFile(lockPath, "utf8");
-    await runActiveOnReadHooks({
-      path: lockPath,
-      scope: "project"
+function serializeJsonMarkdownItemDocument(document, options = {}) {
+  const normalizedMetadata = normalizeItemMetadata(document.metadata, options);
+  const orderedMetadata = orderItemMetadata(normalizedMetadata);
+  const serializedMetadata = JSON.stringify(orderedMetadata, null, 2);
+  const normalizedBody = normalizeBody(document.body ?? "");
+  if (!normalizedBody) {
+    return `${serializedMetadata}
+`;
+  }
+  return `${serializedMetadata}
+
+${normalizedBody}
+`;
+}
+function serializeToonItemDocument(document, options = {}) {
+  const normalizedMetadata = normalizeItemMetadata(document.metadata, options);
+  const orderedMetadata = orderItemMetadata(normalizedMetadata);
+  const normalizedBody = normalizeBody(document.body ?? "");
+  return `${encodeToon({ ...orderedMetadata, 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."
+      ]
     });
-    return parseLockInfo(raw);
-  } catch (error) {
-    if (isErrno(error, "ENOENT")) {
-      return {
-        info: null,
-        warnings: []
-      };
-    }
-    return {
-      info: null,
-      warnings: ["lock_info_read_failed"]
-    };
   }
+  const format = options.format ?? "toon";
+  const runtimeContext = resolveRuntimeSchemaValidationContext(options);
+  return format === "toon" ? parseToonItemDocument(content, runtimeContext, options) : parseJsonMarkdownItemDocument(content, runtimeContext, options);
 }
-function isErrno(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
-async function emitLockWriteHook(lockPath, op) {
-  await runActiveOnWriteHooks({
-    path: lockPath,
-    scope: "project",
-    op
-  });
+function serializeItemDocument(document, options = {}) {
+  const format = options.format ?? "toon";
+  return format === "toon" ? serializeToonItemDocument(document, options) : serializeJsonMarkdownItemDocument(document, options);
 }
-function buildLockPayload(id, owner, ttlSeconds) {
+function canonicalDocument(document, options = {}) {
   return {
-    id,
-    pid: process.pid,
-    owner,
-    created_at: nowIso(),
-    ttl_seconds: ttlSeconds
+    metadata: normalizeItemMetadata(document.metadata, options),
+    body: normalizeBody(document.body ?? "")
   };
 }
-async function createLockFile(lockPath, id, owner, ttlSeconds) {
-  await fs2.mkdir(path2.dirname(lockPath), { recursive: true });
-  const handle = await fs2.open(lockPath, "wx");
-  try {
-    await handle.writeFile(`${JSON.stringify(buildLockPayload(id, owner, ttlSeconds), null, 2)}
-`, "utf8");
-  } finally {
-    await handle.close();
+
+// dist/core/item/item-record.js
+function toItemRecord(item) {
+  return item;
+}
+
+// dist/core/history/history.js
+import jsonPatch from "fast-json-patch";
+var EMPTY_LEGACY_HASH_DOCUMENT = {
+  front_matter: {},
+  body: ""
+};
+function decodeJsonPointer(path6) {
+  if (!path6 || path6 === "/") {
+    return [];
   }
-  await emitLockWriteHook(lockPath, "lock:create");
+  if (!path6.startsWith("/")) {
+    return [];
+  }
+  return path6.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
 }
-async function unlinkLockWithHook(lockPath, op) {
-  try {
-    await fs2.unlink(lockPath);
-    await emitLockWriteHook(lockPath, op);
+function isDefinedPointerPath(document, path6) {
+  const segments = decodeJsonPointer(path6);
+  if (segments.length === 0) {
     return true;
-  } catch {
-    return false;
   }
-}
-function isStaleLock(info, ttlSeconds) {
-  const createdAtMs = info?.created_at ? Date.parse(info.created_at) : Number.NaN;
-  const ageMs = Number.isFinite(createdAtMs) ? Date.now() - createdAtMs : Number.POSITIVE_INFINITY;
-  return ageMs > ttlSeconds * 1e3;
-}
-function lockOwnerSuffix(info) {
-  return info?.owner ? ` (owner ${info.owner})` : "";
-}
-var LOCK_WAIT_INITIAL_DELAY_MS = 25;
-var LOCK_WAIT_MAX_DELAY_MS = 200;
-var LOCK_CONFLICT_RETRY_HINT_MS = 250;
-var MAX_STALE_LOCK_REMOVALS = 3;
-var STALE_CLEANUP_GATE_SUFFIX = ".stale-cleanup";
-var STALE_CLEANUP_GATE_OWNER_FILE = "owner.json";
-var STALE_CLEANUP_GATE_STALE_MS = 1e4;
-var STALE_CLEANUP_GATE_MAX_ACTIVE_MS = 5 * 6e4;
-function parseNonNegativeIntegerWaitMs(value) {
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-      return void 0;
+  let cursor = document;
+  for (const segment of segments) {
+    if (Array.isArray(cursor)) {
+      if (segment === "-" || !/^(0|[1-9]\d*)$/.test(segment)) {
+        return false;
+      }
+      const index = Number(segment);
+      if (!Number.isInteger(index) || index < 0 || index >= cursor.length) {
+        return false;
+      }
+      const next2 = cursor[index];
+      if (next2 === void 0) {
+        return false;
+      }
+      cursor = next2;
+      continue;
     }
-    const parsed = Number(trimmed);
-    return Number.isSafeInteger(parsed) ? parsed : void 0;
-  }
-  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
-    return Math.trunc(value);
+    if (typeof cursor !== "object" || cursor === null) {
+      return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(cursor, segment)) {
+      return false;
+    }
+    const next = cursor[segment];
+    if (next === void 0) {
+      return false;
+    }
+    cursor = next;
   }
-  return void 0;
+  return true;
 }
-function resolveLockWaitMs(waitMs) {
-  const envRaw = process.env.PM_LOCK_WAIT_MS;
-  const envParsed = parseNonNegativeIntegerWaitMs(envRaw);
-  if (envParsed !== void 0) {
-    return envParsed;
-  }
-  const callerParsed = parseNonNegativeIntegerWaitMs(waitMs);
-  if (callerParsed !== void 0) {
-    return callerParsed;
+function normalizeHistoryPatchOps(beforeDocument, patch) {
+  const normalized = [];
+  let replayCursor = structuredClone(beforeDocument);
+  for (const operation of patch) {
+    const normalizedOperation = operation.op === "replace" && !isDefinedPointerPath(replayCursor, operation.path) ? { ...operation, op: "add" } : operation;
+    normalized.push(normalizedOperation);
+    replayCursor = jsonPatch.applyPatch(replayCursor, [normalizedOperation], true, true).newDocument;
   }
-  return 0;
-}
-function sleepWithJitter(baseDelayMs) {
-  const jitteredMs = Math.max(1, Math.round(baseDelayMs * (0.5 + Math.random())));
-  return new Promise((resolve) => setTimeout(resolve, jitteredMs));
-}
-function buildLockConflictError(id, info, waitedMs) {
-  const waitedSuffix = waitedMs > 0 ? ` after waiting ${waitedMs}ms` : "";
-  return new PmCliError(`Item ${id} is locked${lockOwnerSuffix(info)}${waitedSuffix}`, EXIT_CODE.CONFLICT, {
-    code: "lock_conflict",
-    recovery: {
-      retry_after_ms: LOCK_CONFLICT_RETRY_HINT_MS
-    }
-  });
+  return normalized;
 }
-function resolveLockOverrideRelease(result) {
-  if (typeof result === "function") {
-    return result;
-  }
-  if (typeof result === "object" && result !== null && "release" in result) {
-    const release = result.release;
-    return typeof release === "function" ? release : null;
+function canonicalHashDocument(document) {
+  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
+  if (!hasMetadata) {
+    return {
+      front_matter: {},
+      body: document.body ?? ""
+    };
   }
-  return null;
+  const canonical = canonicalDocument(document);
+  const orderedMetadata = orderObject(toItemRecord(canonical.metadata), ITEM_METADATA_KEY_ORDER);
+  return {
+    front_matter: orderedMetadata,
+    body: canonical.body
+  };
 }
-function throwIfStaleLockNeedsForce(id, lockInfo, force, forceRequired) {
-  if (!force && forceRequired) {
-    const warningSuffix = lockInfo.warnings.length > 0 ? ` (${lockInfo.warnings.join(",")})` : "";
-    throw new PmCliError(`Item ${id} lock is stale${warningSuffix}; rerun with --force when supported for this command`, EXIT_CODE.CONFLICT);
+function canonicalPatchDocument(document) {
+  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
+  if (!hasMetadata) {
+    return {
+      metadata: {},
+      body: document.body ?? ""
+    };
   }
+  const canonical = canonicalDocument(document);
+  const orderedMetadata = orderObject(toItemRecord(canonical.metadata), ITEM_METADATA_KEY_ORDER);
+  return {
+    metadata: orderedMetadata,
+    body: canonical.body
+  };
 }
-function parseStaleCleanupGateOwner(raw) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return null;
-  }
-  const candidate = parsed;
-  const pid = candidate.pid;
-  const token = candidate.token;
-  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof token !== "string" || token.length === 0) {
-    return null;
-  }
-  return { pid, token };
+function hashDocument(document) {
+  return sha256Hex(stableStringify(canonicalHashDocument(document)));
 }
-async function readStaleCleanupGateOwner(gatePath) {
-  try {
-    return parseStaleCleanupGateOwner(await fs2.readFile(path2.join(gatePath, STALE_CLEANUP_GATE_OWNER_FILE), "utf8"));
-  } catch {
-    return null;
-  }
+function hashEmptyDocument() {
+  return sha256Hex(stableStringify(EMPTY_LEGACY_HASH_DOCUMENT));
 }
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    if (isErrno(error, "ESRCH")) {
-      return false;
-    }
-    return true;
-  }
+function createHistoryEntry(params) {
+  const beforeHashCanonical = canonicalHashDocument(params.before);
+  const afterHashCanonical = canonicalHashDocument(params.after);
+  const beforePatchCanonical = canonicalPatchDocument(params.before);
+  const afterPatchCanonical = canonicalPatchDocument(params.after);
+  const rawPatch = jsonPatch.compare(beforePatchCanonical, afterPatchCanonical);
+  const patch = normalizeHistoryPatchOps(beforePatchCanonical, rawPatch);
+  return {
+    ts: params.nowIso,
+    author: params.author,
+    op: params.op,
+    patch,
+    before_hash: sha256Hex(stableStringify(beforeHashCanonical)),
+    after_hash: sha256Hex(stableStringify(afterHashCanonical)),
+    message: params.message === void 0 ? void 0 : params.message
+  };
 }
-async function removeStaleCleanupGateDirectory(gatePath) {
-  try {
-    await fs2.rm(gatePath, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function releaseStaleCleanupGate(gatePath, token) {
-  const owner = await readStaleCleanupGateOwner(gatePath);
-  if (owner === null || owner.token !== token) {
-    return;
-  }
-  await removeStaleCleanupGateDirectory(gatePath);
+function fallbackHistoryTimestamp(entry) {
+  const ts = entry.ts.trim();
+  return ts.length > 0 ? ts : nowIso();
 }
-async function tryCreateStaleCleanupGate(gatePath) {
-  try {
-    await fs2.mkdir(gatePath);
-  } catch (error) {
-    if (isErrno(error, "EEXIST")) {
-      return null;
-    }
-    return null;
-  }
-  const owner = { pid: process.pid, token: randomUUID() };
-  try {
-    await fs2.writeFile(path2.join(gatePath, STALE_CLEANUP_GATE_OWNER_FILE), `${JSON.stringify(owner)}
-`, "utf8");
-  } catch {
-    await removeStaleCleanupGateDirectory(gatePath);
-    return null;
+function withHistoryTimestamp(value, fallbackTs) {
+  const ts = value.ts;
+  if (typeof ts === "string" && ts.trim().length > 0) {
+    return value;
   }
-  return owner;
+  return { ...value, ts: fallbackTs };
 }
-async function removeExpiredStaleCleanupGate(gatePath) {
-  let gateAgeMs;
-  try {
-    const stats = await fs2.stat(gatePath);
-    gateAgeMs = Date.now() - stats.mtimeMs;
-    if (gateAgeMs <= STALE_CLEANUP_GATE_STALE_MS) {
-      return false;
+function serializeHistoryLine(value, fallbackEntry) {
+  const fallbackTs = fallbackHistoryTimestamp(fallbackEntry);
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (isRecord(parsed)) {
+        return JSON.stringify(withHistoryTimestamp(parsed, fallbackTs));
+      }
+    } catch {
     }
-  } catch (error) {
-    return isErrno(error, "ENOENT");
-  }
-  const owner = await readStaleCleanupGateOwner(gatePath);
-  if (owner !== null && isProcessAlive(owner.pid) && gateAgeMs <= STALE_CLEANUP_GATE_MAX_ACTIVE_MS) {
-    return false;
-  }
-  return removeStaleCleanupGateDirectory(gatePath);
-}
-async function acquireStaleCleanupGate(lockPath, _id) {
-  const gatePath = `${lockPath}${STALE_CLEANUP_GATE_SUFFIX}`;
-  const owner = await tryCreateStaleCleanupGate(gatePath);
-  if (owner !== null) {
-    return async () => releaseStaleCleanupGate(gatePath, owner.token);
-  }
-  if (!await removeExpiredStaleCleanupGate(gatePath)) {
-    return null;
+    return value;
   }
-  const recoveredOwner = await tryCreateStaleCleanupGate(gatePath);
-  if (recoveredOwner === null) {
-    return null;
+  if (isRecord(value)) {
+    return JSON.stringify(withHistoryTimestamp(value, fallbackTs));
   }
-  return async () => releaseStaleCleanupGate(gatePath, recoveredOwner.token);
+  return JSON.stringify(value);
 }
-async function removeConfirmedStaleLock(params) {
-  const releaseCleanupGate = await acquireStaleCleanupGate(params.lockPath, params.id);
-  if (releaseCleanupGate === null) {
-    return {
-      lockInfo: params.fallbackLockInfo,
-      shouldRetryCreate: false,
-      staleRemovalCounted: false
-    };
-  }
-  try {
-    const currentLockInfo = await readLockInfo(params.lockPath);
-    if (currentLockInfo.info === null && currentLockInfo.warnings.length === 0) {
-      return {
-        lockInfo: currentLockInfo,
-        shouldRetryCreate: true,
-        staleRemovalCounted: false
-      };
+async function appendHistoryEntry(historyPath, entry) {
+  const override = await runActiveServiceOverride("history_append", {
+    history_path: historyPath,
+    entry
+  });
+  if (override.handled) {
+    if (override.result === false) {
+      return;
     }
-    if (!isStaleLock(currentLockInfo.info, params.ttlSeconds)) {
-      return {
-        lockInfo: currentLockInfo,
-        shouldRetryCreate: false,
-        staleRemovalCounted: false
-      };
+    if (typeof override.result === "string") {
+      await appendLineAtomic(historyPath, serializeHistoryLine(override.result, entry));
+      return;
     }
-    throwIfStaleLockNeedsForce(params.id, currentLockInfo, params.force, params.forceRequiredForStaleLock);
-    if (params.staleRemovals >= MAX_STALE_LOCK_REMOVALS) {
-      throw buildLockConflictError(params.id, currentLockInfo.info, Date.now() - params.startedAtMs);
+    if (typeof override.result === "object" && override.result !== null) {
+      const record = override.result;
+      if (record.skip === true) {
+        return;
+      }
+      const nextHistoryPath = typeof record.history_path === "string" ? record.history_path : historyPath;
+      if (typeof record.line === "string") {
+        await appendLineAtomic(nextHistoryPath, serializeHistoryLine(record.line, entry));
+        return;
+      }
+      await appendLineAtomic(nextHistoryPath, serializeHistoryLine(record.entry ?? entry, entry));
+      return;
     }
-    return {
-      lockInfo: currentLockInfo,
-      shouldRetryCreate: await unlinkLockWithHook(params.lockPath, "lock:stale_remove"),
-      staleRemovalCounted: true
-    };
-  } finally {
-    await releaseCleanupGate();
   }
+  await appendLineAtomic(historyPath, serializeHistoryLine(entry, entry));
 }
-async function acquireLock(pmRoot, id, ttlSeconds, owner, force = false, forceRequiredForStaleLock = true, waitMs) {
-  const lockOverride = await runActiveServiceOverride("lock_acquire", {
-    pm_root: pmRoot,
-    id,
-    ttl_seconds: ttlSeconds,
-    owner,
-    force,
-    force_required_for_stale_lock: forceRequiredForStaleLock
+
+// dist/core/history/history-stream-policy.js
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+function toSortedUniqueItemIds(itemIds) {
+  return [...new Set(itemIds.filter((value) => value.trim().length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function strictMissingStreamError(itemId, commandLabel) {
+  return new PmCliError(`Missing history stream for ${itemId}. ${commandLabel} requires history streams when settings.history.missing_stream is strict_error.`, EXIT_CODE.NOT_FOUND);
+}
+async function createStream(historyPath, commandLabel) {
+  await ensureDir(path2.dirname(historyPath));
+  const handle = await fs2.open(historyPath, "a");
+  await handle.close();
+  return runActiveOnWriteHooks({
+    path: historyPath,
+    scope: "project",
+    op: `${commandLabel}:history:auto_create`
   });
-  if (lockOverride.handled) {
-    const release = resolveLockOverrideRelease(lockOverride.result);
-    if (release) {
-      return async () => {
-        await Promise.resolve(release());
-        await runActiveServiceOverride("lock_release", {
-          pm_root: pmRoot,
-          id,
-          owner
-        });
-      };
+}
+async function enforceHistoryStreamPolicyForItem(params) {
+  return enforceHistoryStreamPolicyForItems({
+    pmRoot: params.pmRoot,
+    settings: params.settings,
+    itemIds: [params.itemId],
+    commandLabel: params.commandLabel
+  });
+}
+async function enforceHistoryStreamPolicyForItems(params) {
+  const ids = toSortedUniqueItemIds(params.itemIds);
+  const autoCreated = [];
+  const warnings = [];
+  for (const itemId of ids) {
+    const historyPath = getHistoryPath(params.pmRoot, itemId);
+    if (await pathExists(historyPath)) {
+      continue;
     }
-  }
-  const lockPath = getLockPath(pmRoot, id);
-  const waitBudgetMs = resolveLockWaitMs(waitMs);
-  const startedAtMs = Date.now();
-  let staleRemovals = 0;
-  let backoffMs = LOCK_WAIT_INITIAL_DELAY_MS;
-  for (; ; ) {
-    try {
-      await createLockFile(lockPath, id, owner, ttlSeconds);
-      return async () => {
-        await unlinkLockWithHook(lockPath, "lock:release");
-        await runActiveServiceOverride("lock_release", {
-          pm_root: pmRoot,
-          id,
-          owner
-        });
-      };
-    } catch (error) {
-      if (!isErrno(error, "EEXIST")) {
-        throw new PmCliError(`Failed to acquire lock for ${id}: ${toErrorMessage(error)}`, EXIT_CODE.GENERIC_FAILURE);
-      }
-      let lockInfo = await readLockInfo(lockPath);
-      if (isStaleLock(lockInfo.info, ttlSeconds)) {
-        const staleRemoval = await removeConfirmedStaleLock({
-          lockPath,
-          id,
-          ttlSeconds,
-          force,
-          forceRequiredForStaleLock,
-          staleRemovals,
-          waitBudgetMs,
-          startedAtMs,
-          fallbackLockInfo: lockInfo
-        });
-        lockInfo = staleRemoval.lockInfo;
-        if (staleRemoval.staleRemovalCounted) {
-          staleRemovals += 1;
-        }
-        if (staleRemoval.shouldRetryCreate) {
-          continue;
-        }
-      }
-      const elapsedMs = Date.now() - startedAtMs;
-      if (waitBudgetMs === 0 || elapsedMs >= waitBudgetMs) {
-        throw buildLockConflictError(id, lockInfo.info, waitBudgetMs === 0 ? 0 : elapsedMs);
-      }
-      await sleepWithJitter(Math.min(backoffMs, waitBudgetMs - elapsedMs));
-      backoffMs = Math.min(backoffMs * 2, LOCK_WAIT_MAX_DELAY_MS);
+    if (params.settings.history.missing_stream === "strict_error") {
+      throw strictMissingStreamError(itemId, params.commandLabel);
     }
+    warnings.push(...await createStream(historyPath, params.commandLabel));
+    warnings.push(`history_stream_auto_created:${itemId}`);
+    autoCreated.push(itemId);
   }
+  return {
+    auto_created_ids: autoCreated,
+    warnings
+  };
 }
 
 // dist/core/item/id.js
@@ -5367,6 +5378,7 @@ async function deleteItem(params) {
 }
 
 export {
+  createCoreCommandHookContext,
   createSerialQueue,
   setActiveExtensionHooks,
   setActiveExtensionCommands,
@@ -5408,6 +5420,7 @@ export {
   compareTimestampStrings,
   matchesTimestampFilters,
   resolveIsoOrRelative,
+  acquireLock,
   readRuntimeFieldOptionValue,
   coerceRuntimeFieldValue,
   collectRuntimeCreateFieldValues,
@@ -5434,7 +5447,6 @@ export {
   appendHistoryEntry,
   enforceHistoryStreamPolicyForItem,
   enforceHistoryStreamPolicyForItems,
-  acquireLock,
   normalizePrefix,
   normalizeRawItemId,
   normalizeItemId,
@@ -5450,6 +5462,6 @@ export {
   mutateItem,
   deleteItem
 };
-//# sourceMappingURL=chunk-TNGLCRKS.js.map
+//# sourceMappingURL=chunk-GSEADLRH.js.map
 
-//# debugId=d138c09e-ee75-5951-b241-652a22743908
+//# debugId=e468cc5b-3706-5898-8d97-4deeb3bc0835