@unbrained/pm-cli 2026.7.6 → 2026.7.8

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

@@ -1,1704 +0,0 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="c9a5ce7b-7b83-549d-bddc-c6f8ce8564b8")}catch(e){}}();
-import {
-  canonicalDocument,
-  normalizeItemId,
-  normalizeRawItemId,
-  parseItemDocument,
-  serializeItemDocument
-} from "./chunk-G24G7ZAV.js";
-import {
-  nowIso
-} from "./chunk-3GCS5SKL.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  hasActiveOnReadHooks,
-  orderObject,
-  projectAfterCommandItemSnapshot,
-  recordAfterCommandAffectedItem,
-  resolveGovernanceKnobs,
-  runActiveOnReadHooks,
-  runActiveOnWriteHooks,
-  runActiveServiceOverride,
-  sha256Hex,
-  stableStringify
-} from "./chunk-E3SZTQ4K.js";
-import {
-  evictOldestMemoEntries
-} from "./chunk-NNHHXJB2.js";
-import {
-  EMPTY_CANONICAL_DOCUMENT,
-  EXIT_CODE,
-  FRONT_MATTER_KEY_ORDER,
-  ITEM_FILE_EXTENSIONS,
-  TYPE_TO_FOLDER,
-  appendLineAtomic,
-  ensureDir,
-  getHistoryPath,
-  getItemFormatFromPath,
-  getItemPath,
-  getLockPath,
-  levenshteinDistanceWithinLimit,
-  normalizeItemFieldType,
-  pathExists,
-  resolveItemTypeRegistry,
-  toErrorMessage,
-  writeFileAtomic
-} from "./chunk-57NWPFF2.js";
-
-// dist/core/extensions/item-fields.js
-var RESERVED_ITEM_FIELD_NAMES = new Set(FRONT_MATTER_KEY_ORDER);
-function normalizeFieldName(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-function normalizeFieldType(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  return normalizeItemFieldType(value);
-}
-function cloneFieldValue(value) {
-  try {
-    return structuredClone(value);
-  } catch {
-    return value;
-  }
-}
-function parseFieldAssignment(raw) {
-  const trimmed = raw.trim();
-  const separatorIndex = trimmed.indexOf("=");
-  if (separatorIndex <= 0) {
-    throw new PmCliError(`--field entries must use name=value syntax, received: ${raw}`, EXIT_CODE.USAGE);
-  }
-  const key = trimmed.slice(0, separatorIndex).trim();
-  const value = trimmed.slice(separatorIndex + 1);
-  return { key, value };
-}
-function parseJsonFieldValue(raw, fieldName, expectedType) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (expectedType === "array" && Array.isArray(parsed)) {
-      return parsed;
-    }
-    if (expectedType === "object" && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      return parsed;
-    }
-  } catch {
-  }
-  throw new PmCliError(`--field ${fieldName}=... must be valid JSON ${expectedType}`, EXIT_CODE.USAGE);
-}
-function coerceRegisteredFieldValue(fieldName, fieldType, raw) {
-  if (fieldType === "string") {
-    return raw;
-  }
-  if (fieldType === "number") {
-    const trimmed = raw.trim();
-    if (trimmed.length === 0) {
-      throw new PmCliError(`--field ${fieldName}=... must be a number`, EXIT_CODE.USAGE);
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isFinite(parsed)) {
-      throw new PmCliError(`--field ${fieldName}=... must be a number`, EXIT_CODE.USAGE);
-    }
-    return parsed;
-  }
-  if (fieldType === "boolean") {
-    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(`--field ${fieldName}=... must be one of true|false|1|0|yes|no`, EXIT_CODE.USAGE);
-  }
-  return parseJsonFieldValue(raw, fieldName, fieldType);
-}
-function collectRegisteredFieldDefinitions(registrations) {
-  const definitions = /* @__PURE__ */ new Map();
-  if (!registrations) {
-    return definitions;
-  }
-  for (const registration of registrations.item_fields) {
-    for (const definition of registration.fields) {
-      const fieldName = normalizeFieldName(definition.name);
-      const fieldType = normalizeFieldType(definition.type);
-      if (!fieldName || !fieldType) {
-        continue;
-      }
-      const existing = definitions.get(fieldName);
-      if (existing && existing.type !== fieldType) {
-        throw new PmCliError(`Extension item field "${fieldName}" is declared with conflicting types: ${existing.type}, ${fieldType}`, EXIT_CODE.USAGE, {
-          code: "extension_item_field_type_conflict",
-          nextSteps: ["Make every active extension declaration for this field use the same type."]
-        });
-      }
-      definitions.set(fieldName, { name: fieldName, type: fieldType });
-    }
-  }
-  return definitions;
-}
-function assertNotReservedItemFieldName(fieldName) {
-  if (!RESERVED_ITEM_FIELD_NAMES.has(fieldName)) {
-    return;
-  }
-  throw new PmCliError(`Extension item field "${fieldName}" collides with reserved item metadata`, EXIT_CODE.USAGE, {
-    code: "extension_item_field_reserved",
-    nextSteps: ["Rename the extension item field, preferably with an extension-specific prefix."]
-  });
-}
-function collectRegisteredItemFieldNames(registrations) {
-  return [...collectRegisteredFieldDefinitions(registrations).keys()].sort((left, right) => left.localeCompare(right));
-}
-function parseRegisteredItemFieldAssignments(rawFields, registrations) {
-  if (!rawFields || rawFields.length === 0) {
-    return {};
-  }
-  const definitions = collectRegisteredFieldDefinitions(registrations);
-  const values = {};
-  for (const raw of rawFields) {
-    const { key, value } = parseFieldAssignment(raw);
-    const definition = definitions.get(key);
-    if (!definition) {
-      const known = [...definitions.keys()].sort((left, right) => left.localeCompare(right));
-      throw new PmCliError(`--field ${key} is not declared by an active extension item-field registration`, EXIT_CODE.USAGE, {
-        code: "extension_item_field_unknown",
-        recovery: { provided_fields: known },
-        nextSteps: known.length > 0 ? [`Use one of the declared fields: ${known.join(", ")}`] : ["Activate an extension that calls registerItemFields before setting extension fields."]
-      });
-    }
-    assertNotReservedItemFieldName(definition.name);
-    values[definition.name] = coerceRegisteredFieldValue(definition.name, definition.type, value);
-  }
-  return values;
-}
-function isValidFieldType(value, expectedType) {
-  if (expectedType === "string") {
-    return typeof value === "string";
-  }
-  if (expectedType === "number") {
-    return typeof value === "number" && Number.isFinite(value);
-  }
-  if (expectedType === "boolean") {
-    return typeof value === "boolean";
-  }
-  if (expectedType === "array") {
-    return Array.isArray(value);
-  }
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isAllowedFieldValue(value, allowed) {
-  if (!allowed || allowed.length === 0) {
-    return true;
-  }
-  return allowed.some((candidate) => Object.is(candidate, value));
-}
-function applyRegisteredItemFieldDefaultsAndValidation(frontMatter, registrations, options = {}) {
-  if (!registrations) {
-    return;
-  }
-  collectRegisteredFieldDefinitions(registrations);
-  for (const registration of registrations.item_fields) {
-    for (const definition of registration.fields) {
-      const fieldName = normalizeFieldName(definition.name);
-      if (!fieldName) {
-        continue;
-      }
-      assertNotReservedItemFieldName(fieldName);
-      if (!(fieldName in frontMatter) && !options.skipDefaultFields?.has(fieldName) && Object.prototype.hasOwnProperty.call(definition, "default")) {
-        frontMatter[fieldName] = cloneFieldValue(definition.default);
-      }
-      const currentValue = frontMatter[fieldName];
-      if (currentValue === void 0) {
-        continue;
-      }
-      const expectedType = normalizeFieldType(definition.type);
-      if (expectedType && !isValidFieldType(currentValue, expectedType)) {
-        throw new TypeError(`Item field "${fieldName}" must be of type ${expectedType}`);
-      }
-      const allowedValues = Array.isArray(definition.values) ? definition.values : void 0;
-      if (!isAllowedFieldValue(currentValue, allowedValues)) {
-        throw new TypeError(`Item field "${fieldName}" must match one of the configured allowed values`);
-      }
-    }
-  }
-}
-
-// 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(path5) {
-  if (!path5 || path5 === "/") {
-    return [];
-  }
-  if (!path5.startsWith("/")) {
-    return [];
-  }
-  return path5.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
-}
-function isDefinedPointerPath(document, path5) {
-  const segments = decodeJsonPointer(path5);
-  if (segments.length === 0) {
-    return true;
-  }
-  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;
-    }
-    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 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;
-  }
-  return normalized;
-}
-function canonicalHashDocument(document) {
-  const hasMetadata = document.metadata && Object.keys(document.metadata).length > 0;
-  if (!hasMetadata) {
-    return {
-      front_matter: {},
-      body: document.body ?? ""
-    };
-  }
-  const canonical = canonicalDocument(document);
-  const orderedFrontMatter = orderObject(toItemRecord(canonical.metadata), FRONT_MATTER_KEY_ORDER);
-  return {
-    front_matter: orderedFrontMatter,
-    body: canonical.body
-  };
-}
-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), FRONT_MATTER_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 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 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 {
-    }
-    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 (typeof override.result === "string") {
-      await appendLineAtomic(historyPath, serializeHistoryLine(override.result, entry));
-      return;
-    }
-    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;
-    }
-  }
-  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));
-}
-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(path.dirname(historyPath));
-  const handle = await fs.open(historyPath, "a");
-  await handle.close();
-  return runActiveOnWriteHooks({
-    path: historyPath,
-    scope: "project",
-    op: `${commandLabel}:history:auto_create`
-  });
-}
-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;
-    }
-    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/lock/lock.js
-import fs2 from "node:fs/promises";
-import path2 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"]
-    };
-  }
-  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: []
-  };
-}
-async function readLockInfo(lockPath) {
-  try {
-    const raw = await fs2.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"]
-    };
-  }
-}
-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 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();
-  }
-  await emitLockWriteHook(lockPath, "lock:create");
-}
-async function unlinkLockWithHook(lockPath, op) {
-  try {
-    await fs2.unlink(lockPath);
-    await emitLockWriteHook(lockPath, op);
-    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;
-    }
-    const parsed = Number(trimmed);
-    return Number.isSafeInteger(parsed) ? parsed : void 0;
-  }
-  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
-    return Math.trunc(value);
-  }
-  return void 0;
-}
-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;
-  }
-  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
-    }
-  });
-}
-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;
-  }
-  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);
-  }
-}
-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 };
-}
-async function readStaleCleanupGateOwner(gatePath) {
-  try {
-    return parseStaleCleanupGateOwner(await fs2.readFile(path2.join(gatePath, STALE_CLEANUP_GATE_OWNER_FILE), "utf8"));
-  } catch {
-    return null;
-  }
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    if (isErrno(error, "ESRCH")) {
-      return false;
-    }
-    return true;
-  }
-}
-async function removeStaleCleanupGateDirectory(gatePath) {
-  try {
-    await fs2.rm(gatePath, { recursive: true, force: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function releaseStaleCleanupGate(gatePath, token) {
-  const owner = await readStaleCleanupGateOwner(gatePath);
-  if (owner === null || owner.token !== token) {
-    return;
-  }
-  await removeStaleCleanupGateDirectory(gatePath);
-}
-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;
-  }
-  return owner;
-}
-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;
-    }
-  } 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;
-  }
-  const recoveredOwner = await tryCreateStaleCleanupGate(gatePath);
-  if (recoveredOwner === null) {
-    return null;
-  }
-  return async () => releaseStaleCleanupGate(gatePath, recoveredOwner.token);
-}
-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
-      };
-    }
-    if (!isStaleLock(currentLockInfo.info, params.ttlSeconds)) {
-      return {
-        lockInfo: currentLockInfo,
-        shouldRetryCreate: false,
-        staleRemovalCounted: false
-      };
-    }
-    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 {
-      lockInfo: currentLockInfo,
-      shouldRetryCreate: await unlinkLockWithHook(params.lockPath, "lock:stale_remove"),
-      staleRemovalCounted: true
-    };
-  } finally {
-    await releaseCleanupGate();
-  }
-}
-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);
-    }
-  }
-}
-
-// dist/core/store/front-matter-cache.js
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
-import { createHash } from "node:crypto";
-var CACHE_VERSION = 6;
-var CACHE_FILENAME = "metadata-cache.json";
-var BODY_CACHE_FILENAME = "metadata-cache-bodies.json";
-var COLLECTIONS_CACHE_FILENAME = "metadata-cache-collections.json";
-var HEAVY_METADATA_KEYS = [
-  "comments",
-  "notes",
-  "learnings",
-  "files",
-  "tests",
-  "test_runs",
-  "docs"
-];
-function resolveActiveExtensionFieldNames() {
-  return collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
-}
-function splitHeavyMetadata(metadata) {
-  const light = { ...metadata };
-  const heavy = {};
-  for (const key of HEAVY_METADATA_KEYS) {
-    if (key in light) {
-      heavy[key] = light[key];
-      delete light[key];
-    }
-  }
-  return { light, heavy };
-}
-function mergeHeavyMetadata(light, heavy) {
-  if (!heavy || Object.keys(heavy).length === 0) {
-    return light;
-  }
-  return { ...light, ...heavy };
-}
-function computeContextFingerprint(preferredFormat, typeToFolder, schema, extensionFieldNames) {
-  const hash = createHash("sha256");
-  hash.update(`format:${preferredFormat ?? "default"}`);
-  const sortedTypes = Object.entries(typeToFolder).sort(([a], [b]) => a.localeCompare(b)).map(([type, folder]) => `${type}=${folder}`).join(",");
-  hash.update(`|types:${sortedTypes}`);
-  if (schema) {
-    hash.update(`|schema:${JSON.stringify(schema)}`);
-  }
-  if (extensionFieldNames.length > 0) {
-    hash.update(`|extension_fields:${extensionFieldNames.join(",")}`);
-  }
-  return hash.digest("hex").slice(0, 16);
-}
-function getCachePath(pmRoot) {
-  return path3.join(pmRoot, "runtime", CACHE_FILENAME);
-}
-function getBodyCachePath(pmRoot) {
-  return path3.join(pmRoot, "runtime", BODY_CACHE_FILENAME);
-}
-function getCollectionsCachePath(pmRoot) {
-  return path3.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
-}
-var ENVELOPE_MEMO_MAX_ENTRIES = 24;
-var envelopeMemo = /* @__PURE__ */ new Map();
-function memoizeEnvelope(cachePath, entry) {
-  if (envelopeMemo.size >= ENVELOPE_MEMO_MAX_ENTRIES && !envelopeMemo.has(cachePath)) {
-    evictOldestMemoEntries(envelopeMemo);
-  }
-  envelopeMemo.set(cachePath, entry);
-}
-async function loadEnvelopeMemoized(cachePath, parse) {
-  let stat;
-  try {
-    stat = await fs3.stat(cachePath);
-  } catch {
-    envelopeMemo.delete(cachePath);
-    return null;
-  }
-  const memoized = envelopeMemo.get(cachePath);
-  if (memoized && statMatches(memoized.signature, stat.mtimeMs, stat.ctimeMs, stat.size)) {
-    envelopeMemo.delete(cachePath);
-    envelopeMemo.set(cachePath, memoized);
-    return memoized.envelope;
-  }
-  let envelope;
-  try {
-    envelope = parse(await fs3.readFile(cachePath, "utf8"));
-  } catch {
-    envelope = null;
-  }
-  memoizeEnvelope(cachePath, {
-    signature: { mtime_ms: stat.mtimeMs, ctime_ms: stat.ctimeMs, size: stat.size },
-    envelope
-  });
-  return envelope;
-}
-async function loadCache(pmRoot) {
-  return await loadEnvelopeMemoized(getCachePath(pmRoot), (raw) => {
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
-      return null;
-    }
-    return parsed;
-  });
-}
-async function loadBodyCache(pmRoot) {
-  return await loadEnvelopeMemoized(getBodyCachePath(pmRoot), (raw) => {
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== CACHE_VERSION || typeof parsed.bodies !== "object" || parsed.bodies === null) {
-      return null;
-    }
-    return parsed;
-  });
-}
-async function loadCollectionsCache(pmRoot) {
-  return await loadEnvelopeMemoized(getCollectionsCachePath(pmRoot), (raw) => {
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== CACHE_VERSION || typeof parsed.collections !== "object" || parsed.collections === null) {
-      return null;
-    }
-    return parsed;
-  });
-}
-async function persistCache(cachePath, envelope) {
-  await fs3.mkdir(path3.dirname(cachePath), { recursive: true });
-  await writeFileAtomic(cachePath, JSON.stringify(envelope));
-  try {
-    const stat = await fs3.stat(cachePath);
-    memoizeEnvelope(cachePath, {
-      signature: { mtime_ms: stat.mtimeMs, ctime_ms: stat.ctimeMs, size: stat.size },
-      envelope
-    });
-  } catch {
-    envelopeMemo.delete(cachePath);
-  }
-}
-function shouldReplaceCachedDocumentCandidate(existingFormat, candidateFormat, preferredFormat) {
-  if (preferredFormat) {
-    return candidateFormat === preferredFormat && existingFormat !== preferredFormat;
-  }
-  return candidateFormat === "toon" && existingFormat !== "toon";
-}
-function appendWarning(warnings, warning) {
-  if (warnings && !warnings.includes(warning)) {
-    warnings.push(warning);
-  }
-}
-function statMatches(signature, mtimeMs, ctimeMs, size) {
-  return signature.mtime_ms === mtimeMs && signature.ctime_ms === ctimeMs && signature.size === size;
-}
-async function readItemDirectoryFiles(pmRoot, folder, warnings) {
-  const dirPath = path3.join(pmRoot, folder);
-  try {
-    const files = await fs3.readdir(dirPath);
-    return { folder, dirPath, files };
-  } catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
-      appendWarning(warnings, `item_list_directory_read_failed:${folder}`);
-    }
-    return { folder, dirPath, files: [] };
-  }
-}
-function isItemDocumentFile(file) {
-  return ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext));
-}
-function markDocumentCacheMisses(misses, includeBody, includeCollections, metadataCached, bodyCached, collectionsCached) {
-  if (!metadataCached) {
-    misses.metadata = true;
-  }
-  if (includeBody && !bodyCached) {
-    misses.body = true;
-  }
-  if (includeCollections && !collectionsCached) {
-    misses.collections = true;
-  }
-}
-async function dispatchCachedDocumentReadHooks(filePath, warnings, dispatchReadHooks) {
-  if (!dispatchReadHooks) {
-    return;
-  }
-  for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
-    appendWarning(warnings, warning);
-  }
-}
-async function readCachedDocumentParts(filePath, relativePath, context) {
-  const stat = await fs3.stat(filePath);
-  const mtimeMs = stat.mtimeMs;
-  const ctimeMs = stat.ctimeMs;
-  const { size } = stat;
-  const itemFormat = getItemFormatFromPath(filePath);
-  await dispatchCachedDocumentReadHooks(filePath, context.warnings, context.dispatchReadHooks);
-  const cachedEntry = context.previousEntries[relativePath];
-  const metadataCached = cachedEntry !== void 0 && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
-  const cachedBody = context.previousBodies[relativePath];
-  const bodyCached = cachedBody !== void 0 && statMatches(cachedBody, mtimeMs, ctimeMs, size);
-  const cachedCollections = context.previousCollections[relativePath];
-  const collectionsCached = cachedCollections !== void 0 && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
-  const needRead = !metadataCached || context.includeBody && !bodyCached || context.includeCollections && !collectionsCached;
-  if (!needRead) {
-    return {
-      mtimeMs,
-      ctimeMs,
-      size,
-      itemFormat,
-      lightMetadata: cachedEntry.metadata,
-      heavyMetadata: context.includeCollections && cachedCollections ? cachedCollections.collections : void 0,
-      bodyLength: cachedEntry.body_length,
-      body: context.includeBody ? cachedBody.body : void 0
-    };
-  }
-  const raw = await fs3.readFile(filePath, "utf8");
-  const parsed = parseItemDocument(raw, {
-    format: itemFormat,
-    schema: context.schema,
-    extensionFieldNames: context.extensionFieldNames,
-    onWarning: (warning) => appendWarning(context.warnings, warning)
-  });
-  const split = splitHeavyMetadata(parsed.metadata);
-  markDocumentCacheMisses(context.state.misses, context.includeBody, context.includeCollections, metadataCached, bodyCached, collectionsCached);
-  return {
-    mtimeMs,
-    ctimeMs,
-    size,
-    itemFormat,
-    lightMetadata: metadataCached ? cachedEntry.metadata : split.light,
-    heavyMetadata: context.includeCollections ? collectionsCached ? cachedCollections.collections : split.heavy : void 0,
-    bodyLength: metadataCached ? cachedEntry.body_length : parsed.body.length,
-    body: context.includeBody ? parsed.body : void 0
-  };
-}
-function recordCachedDocumentCandidate(filePath, relativePath, context, parts) {
-  context.state.newEntries[relativePath] = {
-    mtime_ms: parts.mtimeMs,
-    ctime_ms: parts.ctimeMs,
-    size: parts.size,
-    metadata: parts.lightMetadata,
-    body_length: parts.bodyLength
-  };
-  if (context.includeBody && parts.body !== void 0) {
-    context.state.newBodies[relativePath] = {
-      mtime_ms: parts.mtimeMs,
-      ctime_ms: parts.ctimeMs,
-      size: parts.size,
-      body: parts.body
-    };
-  }
-  if (context.includeCollections && parts.heavyMetadata !== void 0) {
-    context.state.newCollections[relativePath] = {
-      mtime_ms: parts.mtimeMs,
-      ctime_ms: parts.ctimeMs,
-      size: parts.size,
-      collections: parts.heavyMetadata
-    };
-  }
-  const metadata = context.includeCollections ? mergeHeavyMetadata(parts.lightMetadata, parts.heavyMetadata) : parts.lightMetadata;
-  const existing = context.state.documentsById.get(metadata.id);
-  const candidate = {
-    metadata,
-    body: parts.body,
-    item_format: parts.itemFormat,
-    item_path: filePath
-  };
-  if (!existing || shouldReplaceCachedDocumentCandidate(existing.itemFormat, parts.itemFormat, context.preferredFormat)) {
-    context.state.documentsById.set(metadata.id, { candidate, itemFormat: parts.itemFormat });
-  }
-}
-async function processCachedDocumentFile(folder, filePath, relativePath, context) {
-  try {
-    const parts = await readCachedDocumentParts(filePath, relativePath, context);
-    recordCachedDocumentCandidate(filePath, relativePath, context, parts);
-  } catch {
-    appendWarning(context.warnings, `item_list_item_read_failed:${folder}/${path3.basename(filePath)}`);
-  }
-}
-function selectPreviousMetadataEntries(existingCache, contextFingerprint) {
-  return existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
-}
-function selectPreviousBodyEntries(existingBodyCache, contextFingerprint) {
-  return existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
-}
-function selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint) {
-  return existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint ? existingCollectionsCache.collections : {};
-}
-function createDocumentCacheMutableState() {
-  return {
-    newEntries: {},
-    newBodies: {},
-    newCollections: {},
-    documentsById: /* @__PURE__ */ new Map(),
-    misses: {
-      metadata: false,
-      body: false,
-      collections: false
-    }
-  };
-}
-function collectCachedDocumentParseTasks(dirResults, context) {
-  const parseTasks = [];
-  for (const { folder, dirPath, files } of dirResults) {
-    for (const file of files) {
-      if (!isItemDocumentFile(file)) {
-        continue;
-      }
-      const filePath = path3.join(dirPath, file);
-      const relativePath = path3.relative(context.pmRoot, filePath);
-      parseTasks.push(processCachedDocumentFile(folder, filePath, relativePath, context));
-    }
-  }
-  return parseTasks;
-}
-async function persistMetadataCacheIfNeeded(params) {
-  const metadataDirty = params.state.misses.metadata || Object.keys(params.previousEntries).length !== Object.keys(params.state.newEntries).length;
-  if (!metadataDirty && params.existingCache !== null && params.existingCache.context_fingerprint === params.contextFingerprint) {
-    return;
-  }
-  await persistCache(getCachePath(params.pmRoot), {
-    version: CACHE_VERSION,
-    context_fingerprint: params.contextFingerprint,
-    entries: params.state.newEntries
-  }).catch(() => {
-  });
-}
-async function persistBodyCacheIfNeeded(params) {
-  const bodyDirty = params.state.misses.body || Object.keys(params.previousBodies).length !== Object.keys(params.state.newBodies).length;
-  if (!bodyDirty && params.existingBodyCache !== null && params.existingBodyCache.context_fingerprint === params.contextFingerprint) {
-    return;
-  }
-  await persistCache(getBodyCachePath(params.pmRoot), {
-    version: CACHE_VERSION,
-    context_fingerprint: params.contextFingerprint,
-    bodies: params.state.newBodies
-  }).catch(() => {
-  });
-}
-async function persistCollectionsCacheIfNeeded(params) {
-  const collectionsDirty = params.state.misses.collections || Object.keys(params.previousCollections).length !== Object.keys(params.state.newCollections).length;
-  if (!collectionsDirty && params.existingCollectionsCache !== null && params.existingCollectionsCache.context_fingerprint === params.contextFingerprint) {
-    return;
-  }
-  await persistCache(getCollectionsCachePath(params.pmRoot), {
-    version: CACHE_VERSION,
-    context_fingerprint: params.contextFingerprint,
-    collections: params.state.newCollections
-  }).catch(() => {
-  });
-}
-function sortedCachedDocumentCandidates(state) {
-  return [...state.documentsById.values()].sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id)).map((entry) => entry.candidate);
-}
-async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, options = {}) {
-  const includeBody = options.includeBody !== false;
-  const includeCollections = options.includeCollections !== false;
-  const extensionFieldNames = resolveActiveExtensionFieldNames();
-  const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema, extensionFieldNames);
-  const existingCache = await loadCache(pmRoot);
-  const previousEntries = selectPreviousMetadataEntries(existingCache, contextFingerprint);
-  const existingBodyCache = includeBody ? await loadBodyCache(pmRoot) : null;
-  const previousBodies = selectPreviousBodyEntries(existingBodyCache, contextFingerprint);
-  const existingCollectionsCache = includeCollections ? await loadCollectionsCache(pmRoot) : null;
-  const previousCollections = selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint);
-  const entries = Object.entries(typeToFolder);
-  const dirResults = await Promise.all(entries.map(([, folder]) => readItemDirectoryFiles(pmRoot, folder, warnings)));
-  const dispatchReadHooks = hasActiveOnReadHooks();
-  const state = createDocumentCacheMutableState();
-  const context = {
-    pmRoot,
-    preferredFormat,
-    warnings,
-    schema,
-    extensionFieldNames,
-    includeBody,
-    includeCollections,
-    dispatchReadHooks,
-    previousEntries,
-    previousBodies,
-    previousCollections,
-    state
-  };
-  await Promise.all(collectCachedDocumentParseTasks(dirResults, context));
-  await persistMetadataCacheIfNeeded({ pmRoot, contextFingerprint, existingCache, previousEntries, state });
-  if (includeBody) {
-    await persistBodyCacheIfNeeded({ pmRoot, contextFingerprint, existingBodyCache, previousBodies, state });
-  }
-  if (includeCollections) {
-    await persistCollectionsCacheIfNeeded({ pmRoot, contextFingerprint, existingCollectionsCache, previousCollections, state });
-  }
-  return sortedCachedDocumentCandidates(state);
-}
-async function listAllDocumentsCached(pmRoot, preferredFormat, typeToFolder, warnings, schema) {
-  const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, {
-    includeBody: false
-  });
-  return candidates.map((candidate) => ({
-    metadata: candidate.metadata,
-    body: candidate.body ?? ""
-  }));
-}
-async function listAllDocumentsCachedLight(pmRoot, preferredFormat, typeToFolder, warnings, schema) {
-  const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, {
-    includeBody: false,
-    includeCollections: false
-  });
-  return candidates.map((candidate) => ({
-    metadata: candidate.metadata,
-    body: candidate.body ?? ""
-  }));
-}
-
-// dist/core/store/item-store.js
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
-async function fileExists(targetPath) {
-  try {
-    await fs4.access(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function appendWarning2(warnings, warning) {
-  if (!warnings) {
-    return;
-  }
-  if (!warnings.includes(warning)) {
-    warnings.push(warning);
-  }
-}
-function resolveActiveExtensionFieldNames2(explicit) {
-  return explicit ?? collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
-}
-function resolveItemFormatSearchOrder(preferredFormat) {
-  if (preferredFormat === "toon") {
-    return ["toon", "json_markdown"];
-  }
-  if (preferredFormat === "json_markdown") {
-    return ["json_markdown", "toon"];
-  }
-  return ["toon", "json_markdown"];
-}
-async function locateItem(pmRoot, rawId, idPrefix = "pm-", preferredFormat, typeToFolder = TYPE_TO_FOLDER) {
-  const normalizedId = normalizeItemId(rawId, idPrefix);
-  const rawNormalizedId = normalizeRawItemId(rawId);
-  const candidateIds = normalizedId === rawNormalizedId ? [normalizedId] : [normalizedId, rawNormalizedId];
-  const entries = Object.entries(typeToFolder);
-  const searchOrder = resolveItemFormatSearchOrder(preferredFormat);
-  for (const candidateId of candidateIds) {
-    for (const [type] of entries) {
-      for (const itemFormat of searchOrder) {
-        const itemPath = getItemPath(pmRoot, type, candidateId, itemFormat, typeToFolder);
-        if (await fileExists(itemPath)) {
-          return {
-            id: candidateId,
-            type,
-            itemPath,
-            item_format: itemFormat
-          };
-        }
-      }
-    }
-  }
-  return null;
-}
-async function readLocatedItem(item, options = {}) {
-  const raw = await fs4.readFile(item.itemPath, "utf8");
-  await runActiveOnReadHooks({
-    path: item.itemPath,
-    scope: "project"
-  });
-  const document = parseItemDocument(raw, {
-    format: item.item_format,
-    schema: options.schema,
-    extensionFieldNames: resolveActiveExtensionFieldNames2(options.extensionFieldNames),
-    onWarning: (warning) => appendWarning2(options.warnings, warning)
-  });
-  return { raw, document };
-}
-async function listAllFrontMatter(pmRoot, preferredFormat, typeToFolder = TYPE_TO_FOLDER, warnings, schema) {
-  const documents = await listAllDocumentsCached(pmRoot, preferredFormat, typeToFolder, warnings, schema);
-  return documents.map((document) => document.metadata);
-}
-async function listAllFrontMatterLight(pmRoot, preferredFormat, typeToFolder = TYPE_TO_FOLDER, warnings, schema) {
-  const documents = await listAllDocumentsCachedLight(pmRoot, preferredFormat, typeToFolder, warnings, schema);
-  return documents.map((document) => document.metadata);
-}
-async function listAllFrontMatterWithBody(pmRoot, preferredFormat, typeToFolder = TYPE_TO_FOLDER, warnings, schema) {
-  const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, { includeBody: true });
-  return candidates.map((candidate) => ({
-    ...candidate.metadata,
-    // includeBody:true guarantees candidate bodies are materialized.
-    body: candidate.body
-  }));
-}
-async function listKnownItemIds(pmRoot, typeToFolder) {
-  const folders = new Set(Object.values(typeToFolder));
-  const allIds = [];
-  await Promise.all([...folders].map(async (folder) => {
-    try {
-      const entries = await fs4.readdir(path4.join(pmRoot, folder));
-      for (const entry of entries) {
-        for (const ext of ITEM_FILE_EXTENSIONS) {
-          if (entry.toLowerCase().endsWith(ext)) {
-            allIds.push(entry.slice(0, -ext.length));
-            break;
-          }
-        }
-      }
-    } catch {
-    }
-  }));
-  return allIds;
-}
-async function buildDidYouMeanSuggestions(pmRoot, badId, idPrefix, typeToFolder) {
-  const normalized = normalizeItemId(badId, idPrefix);
-  const ids = await listKnownItemIds(pmRoot, typeToFolder);
-  if (ids.length === 0)
-    return [];
-  const limit = Math.max(3, Math.floor(normalized.length / 2));
-  const scored = ids.map((id) => ({ id, distance: levenshteinDistanceWithinLimit(id, normalized, limit) })).filter((entry) => entry.distance !== null).sort((left, right) => left.distance - right.distance).slice(0, 3).map((entry) => entry.id);
-  return scored;
-}
-async function buildItemNotFoundError(pmRoot, badId, idPrefix, typeToFolder) {
-  const suggestions = await buildDidYouMeanSuggestions(pmRoot, badId, idPrefix, typeToFolder);
-  const nextSteps = ["Confirm the active --path/PM_PATH scope, then retry with a valid id."];
-  if (suggestions.length > 0) {
-    nextSteps.unshift(`Did you mean one of: ${suggestions.join(", ")}?`);
-  }
-  return new PmCliError(`Item ${badId} not found`, EXIT_CODE.NOT_FOUND, { nextSteps });
-}
-function bypassesAssigneeConflict(op, bypassAssigneeConflict) {
-  return op === "claim" || bypassAssigneeConflict === true && (op === "comment_add" || op === "comment_edit" || op === "comment_delete" || op === "note_add" || op === "learning_add" || op === "release" || op === "update" || op === "update_audit");
-}
-async function prepareLockedItem(params) {
-  const typeToFolder = params.typeToFolder ?? resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations()).type_to_folder;
-  const located = await locateItem(params.pmRoot, params.id, params.settings.id_prefix, params.settings.item_format, typeToFolder);
-  if (!located) {
-    throw await buildItemNotFoundError(params.pmRoot, params.id, params.settings.id_prefix, typeToFolder);
-  }
-  const releaseLock = await acquireLock(params.pmRoot, located.id, params.settings.locks.ttl_seconds, params.author, Boolean(params.force), params.settings.governance.force_required_for_stale_lock, params.settings.locks.wait_ms);
-  try {
-    const warnings = [];
-    const { raw: originalRaw, document } = await readLocatedItem(located, {
-      schema: params.settings.schema,
-      extensionFieldNames: params.extensionFieldNames,
-      warnings
-    });
-    const assigned = document.metadata.assignee?.trim();
-    const governance = resolveGovernanceKnobs(params.settings);
-    const hasOwnershipConflict = assigned && assigned !== params.author && !params.force && !bypassesAssigneeConflict(params.op, params.bypassAssigneeConflict);
-    if (hasOwnershipConflict) {
-      if (governance.ownership_enforcement === "strict") {
-        throw new PmCliError(`Item ${located.id} is assigned to ${assigned}. Use --force to override.`, EXIT_CODE.CONFLICT);
-      }
-      if (governance.ownership_enforcement === "warn") {
-        warnings.push(`ownership_warning:assignee_conflict:${located.id}:${assigned}`);
-      }
-    }
-    return {
-      typeToFolder,
-      located,
-      originalRaw,
-      document,
-      warnings,
-      releaseLock
-    };
-  } catch (error) {
-    await releaseLock();
-    throw error;
-  }
-}
-function resolveItemStoreWriteOverride(serviceWriteOverride, targetItemPath, serializedAfter) {
-  if (!serviceWriteOverride.handled || typeof serviceWriteOverride.result !== "object" || serviceWriteOverride.result === null) {
-    return { effectiveTargetItemPath: targetItemPath, effectiveSerializedAfter: serializedAfter, skipItemWrite: false };
-  }
-  const overrideRecord = serviceWriteOverride.result;
-  return {
-    effectiveTargetItemPath: typeof overrideRecord.target_item_path === "string" && overrideRecord.target_item_path.trim().length > 0 ? overrideRecord.target_item_path : targetItemPath,
-    effectiveSerializedAfter: typeof overrideRecord.contents === "string" ? overrideRecord.contents : serializedAfter,
-    skipItemWrite: overrideRecord.skip_write === true
-  };
-}
-async function rollbackMutatedItemWrite(params) {
-  if (params.skipItemWrite) {
-    return;
-  }
-  if (params.effectiveTargetItemPath !== params.originalItemPath) {
-    await writeFileAtomic(params.originalItemPath, params.originalRaw);
-    await fs4.rm(params.effectiveTargetItemPath, { force: true });
-    return;
-  }
-  await writeFileAtomic(params.originalItemPath, params.originalRaw);
-}
-async function mutateItem(params) {
-  const prepared = await prepareLockedItem({
-    pmRoot: params.pmRoot,
-    settings: params.settings,
-    id: params.id,
-    op: params.op,
-    author: params.author,
-    force: params.force,
-    bypassAssigneeConflict: params.bypassAssigneeConflict,
-    extensionFieldNames: params.extensionFieldNames,
-    typeToFolder: params.typeToFolder
-  });
-  const { typeToFolder, located, originalRaw, document, warnings: parseWarnings, releaseLock } = prepared;
-  try {
-    const beforeDocument = canonicalDocument(document, {
-      schema: params.settings.schema,
-      extensionFieldNames: params.extensionFieldNames
-    });
-    const mutableDocument = canonicalDocument(structuredClone(document), {
-      schema: params.settings.schema,
-      extensionFieldNames: params.extensionFieldNames
-    });
-    const mutation = params.mutate(mutableDocument);
-    if (params.skipNoop === true && mutation.changedFields.length === 0) {
-      return {
-        item: beforeDocument.metadata,
-        body: beforeDocument.body,
-        changedFields: [],
-        warnings: [...parseWarnings, ...mutation.warnings ?? []]
-      };
-    }
-    const historyPolicy = await enforceHistoryStreamPolicyForItem({
-      pmRoot: params.pmRoot,
-      settings: params.settings,
-      itemId: located.id,
-      commandLabel: params.op
-    });
-    mutableDocument.metadata.updated_at = nowIso();
-    const afterDocument = canonicalDocument(mutableDocument, {
-      schema: params.settings.schema,
-      extensionFieldNames: params.extensionFieldNames
-    });
-    const targetItemFormat = "toon";
-    const serializedAfter = serializeItemDocument(afterDocument, {
-      format: targetItemFormat,
-      schema: params.settings.schema,
-      extensionFieldNames: params.extensionFieldNames
-    });
-    const targetItemPath = getItemPath(params.pmRoot, afterDocument.metadata.type, located.id, targetItemFormat, typeToFolder);
-    const historyPath = getHistoryPath(params.pmRoot, located.id);
-    const serviceWriteOverride = await runActiveServiceOverride("item_store_write", {
-      op: params.op,
-      pm_root: params.pmRoot,
-      item_id: located.id,
-      source_item_path: located.itemPath,
-      target_item_path: targetItemPath,
-      history_path: historyPath,
-      item_format: targetItemFormat,
-      before: beforeDocument,
-      after: afterDocument,
-      contents: serializedAfter
-    });
-    const { effectiveTargetItemPath, effectiveSerializedAfter, skipItemWrite } = resolveItemStoreWriteOverride(serviceWriteOverride, targetItemPath, serializedAfter);
-    if (!skipItemWrite) {
-      await writeFileAtomic(effectiveTargetItemPath, effectiveSerializedAfter);
-    }
-    if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
-      await fs4.rm(located.itemPath);
-    }
-    const entry = createHistoryEntry({
-      nowIso: afterDocument.metadata.updated_at,
-      author: params.author,
-      op: params.op,
-      before: beforeDocument,
-      after: afterDocument,
-      message: params.message
-    });
-    try {
-      await appendHistoryEntry(historyPath, entry);
-    } catch (error) {
-      await rollbackMutatedItemWrite({
-        skipItemWrite,
-        effectiveTargetItemPath,
-        originalItemPath: located.itemPath,
-        originalRaw
-      });
-      throw error;
-    }
-    const hookWarnings = [
-      ...await runActiveOnWriteHooks({
-        path: effectiveTargetItemPath,
-        scope: "project",
-        op: params.op,
-        item_id: afterDocument.metadata.id,
-        item_type: afterDocument.metadata.type,
-        before: beforeDocument,
-        after: afterDocument,
-        changed_fields: mutation.changedFields
-      }),
-      ...await runActiveOnWriteHooks({
-        path: historyPath,
-        scope: "project",
-        op: `${params.op}:history`,
-        item_id: afterDocument.metadata.id,
-        item_type: afterDocument.metadata.type,
-        before: beforeDocument,
-        after: afterDocument,
-        changed_fields: mutation.changedFields
-      })
-    ];
-    recordAfterCommandAffectedItem({
-      id: afterDocument.metadata.id,
-      op: params.op,
-      item_type: afterDocument.metadata.type,
-      previous_status: beforeDocument.metadata.status,
-      status: afterDocument.metadata.status,
-      previous: projectAfterCommandItemSnapshot(beforeDocument.metadata, mutation.changedFields),
-      current: projectAfterCommandItemSnapshot(afterDocument.metadata, mutation.changedFields),
-      changed_fields: mutation.changedFields
-    });
-    return {
-      item: afterDocument.metadata,
-      body: afterDocument.body,
-      changedFields: mutation.changedFields,
-      warnings: [
-        ...parseWarnings,
-        ...mutation.warnings ?? [],
-        ...historyPolicy.warnings,
-        ...serviceWriteOverride.warnings,
-        ...hookWarnings
-      ]
-    };
-  } finally {
-    await releaseLock();
-  }
-}
-async function deleteItem(params) {
-  const prepared = await prepareLockedItem({
-    pmRoot: params.pmRoot,
-    settings: params.settings,
-    id: params.id,
-    op: "delete",
-    author: params.author,
-    force: params.force
-  });
-  const { located, originalRaw, document, warnings: parseWarnings, releaseLock } = prepared;
-  try {
-    const historyPolicy = await enforceHistoryStreamPolicyForItem({
-      pmRoot: params.pmRoot,
-      settings: params.settings,
-      itemId: located.id,
-      commandLabel: "delete"
-    });
-    const beforeDocument = canonicalDocument(document, { schema: params.settings.schema });
-    const deletionTimestamp = nowIso();
-    const tombstoneDocument = EMPTY_CANONICAL_DOCUMENT;
-    const historyEntry = createHistoryEntry({
-      nowIso: deletionTimestamp,
-      author: params.author,
-      op: "delete",
-      before: beforeDocument,
-      after: tombstoneDocument,
-      message: params.message
-    });
-    const historyPath = getHistoryPath(params.pmRoot, located.id);
-    const serviceDeleteOverride = await runActiveServiceOverride("item_store_delete", {
-      op: "delete",
-      pm_root: params.pmRoot,
-      item_id: located.id,
-      item_path: located.itemPath,
-      history_path: historyPath,
-      before: beforeDocument
-    });
-    let effectiveItemPath = located.itemPath;
-    let skipDelete = false;
-    if (serviceDeleteOverride.handled && typeof serviceDeleteOverride.result === "object" && serviceDeleteOverride.result !== null) {
-      const overrideRecord = serviceDeleteOverride.result;
-      if (typeof overrideRecord.item_path === "string" && overrideRecord.item_path.trim().length > 0) {
-        effectiveItemPath = overrideRecord.item_path;
-      }
-      if (overrideRecord.skip_delete === true) {
-        skipDelete = true;
-      }
-    }
-    if (params.dryRun === true) {
-      return {
-        item: beforeDocument.metadata,
-        changedFields: ["deleted"],
-        targetPath: effectiveItemPath,
-        warnings: [...parseWarnings, ...historyPolicy.warnings, ...serviceDeleteOverride.warnings]
-      };
-    }
-    if (!skipDelete) {
-      await fs4.rm(effectiveItemPath);
-    }
-    try {
-      await appendHistoryEntry(historyPath, historyEntry);
-    } catch (error) {
-      if (!skipDelete) {
-        await writeFileAtomic(effectiveItemPath, originalRaw);
-      }
-      throw error;
-    }
-    const hookWarnings = [
-      ...await runActiveOnWriteHooks({
-        path: effectiveItemPath,
-        scope: "project",
-        op: "delete",
-        item_id: beforeDocument.metadata.id,
-        item_type: beforeDocument.metadata.type,
-        before: beforeDocument,
-        after: tombstoneDocument,
-        changed_fields: ["deleted"]
-      }),
-      ...await runActiveOnWriteHooks({
-        path: historyPath,
-        scope: "project",
-        op: "delete:history",
-        item_id: beforeDocument.metadata.id,
-        item_type: beforeDocument.metadata.type,
-        before: beforeDocument,
-        after: tombstoneDocument,
-        changed_fields: ["deleted"]
-      })
-    ];
-    recordAfterCommandAffectedItem({
-      id: beforeDocument.metadata.id,
-      op: "delete",
-      item_type: beforeDocument.metadata.type,
-      previous_status: beforeDocument.metadata.status,
-      previous: projectAfterCommandItemSnapshot(beforeDocument.metadata, Object.keys(beforeDocument.metadata)),
-      changed_fields: ["deleted"]
-    });
-    return {
-      item: beforeDocument.metadata,
-      changedFields: ["deleted"],
-      warnings: [...parseWarnings, ...historyPolicy.warnings, ...serviceDeleteOverride.warnings, ...hookWarnings]
-    };
-  } finally {
-    await releaseLock();
-  }
-}
-
-export {
-  collectRegisteredItemFieldNames,
-  parseRegisteredItemFieldAssignments,
-  applyRegisteredItemFieldDefaultsAndValidation,
-  toItemRecord,
-  hashDocument,
-  hashEmptyDocument,
-  createHistoryEntry,
-  appendHistoryEntry,
-  enforceHistoryStreamPolicyForItem,
-  enforceHistoryStreamPolicyForItems,
-  acquireLock,
-  HEAVY_METADATA_KEYS,
-  listAllDocumentCandidatesCached,
-  locateItem,
-  readLocatedItem,
-  listAllFrontMatter,
-  listAllFrontMatterLight,
-  listAllFrontMatterWithBody,
-  buildItemNotFoundError,
-  mutateItem,
-  deleteItem
-};
-//# sourceMappingURL=chunk-ENGQOEUY.js.map
-
-//# debugId=c9a5ce7b-7b83-549d-bddc-c6f8ce8564b8