@unbrained/pm-cli 2026.5.31 → 2026.6.6

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

@@ -0,0 +1,1340 @@
+
+!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]="83aa0c1e-d8e6-5e3e-ac80-b84dd7ee7bce")}catch(e){}}();
+import {
+  normalizeItemId,
+  normalizeRawItemId
+} from "./chunk-HZGUAH22.js";
+import {
+  canonicalDocument,
+  parseItemDocument,
+  serializeItemDocument
+} from "./chunk-LB3RUL2N.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-2VBQ6ZXS.js";
+import {
+  nowIso
+} from "./chunk-TCD3R2PF.js";
+import {
+  EMPTY_CANONICAL_DOCUMENT,
+  EXIT_CODE,
+  FRONT_MATTER_KEY_ORDER,
+  ITEM_FILE_EXTENSIONS,
+  PmCliError,
+  TYPE_TO_FOLDER,
+  appendLineAtomic,
+  ensureDir,
+  getActiveExtensionRegistrations,
+  getHistoryPath,
+  getItemFormatFromPath,
+  getItemPath,
+  getLockPath,
+  hasActiveOnReadHooks,
+  orderObject,
+  pathExists,
+  projectAfterCommandItemSnapshot,
+  recordAfterCommandAffectedItem,
+  resolveGovernanceKnobs,
+  runActiveOnReadHooks,
+  runActiveOnWriteHooks,
+  runActiveServiceOverride,
+  sha256Hex,
+  stableStringify,
+  toErrorMessage,
+  writeFileAtomic
+} from "./chunk-5SFCOO6B.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;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "string" || normalized === "number" || normalized === "boolean" || normalized === "array" || normalized === "object") {
+    return normalized;
+  }
+  return null;
+}
+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);
+  if (key.length === 0) {
+    throw new PmCliError("--field entries require a non-empty field name", EXIT_CODE.USAGE);
+  }
+  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
+  };
+}
+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, override.result);
+      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, record.line);
+        return;
+      }
+      const nextEntry = record.entry ?? entry;
+      await appendLineAtomic(nextHistoryPath, JSON.stringify(nextEntry));
+      return;
+    }
+  }
+  await appendLineAtomic(historyPath, JSON.stringify(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";
+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);
+  } catch {
+  }
+}
+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})` : "";
+}
+async function handleExistingLock(lockPath, id, ttlSeconds, force, forceRequiredForStaleLock) {
+  const lockInfo = await readLockInfo(lockPath);
+  if (!isStaleLock(lockInfo.info, ttlSeconds)) {
+    throw new PmCliError(`Item ${id} is locked${lockOwnerSuffix(lockInfo.info)}`, EXIT_CODE.CONFLICT);
+  }
+  if (!force && forceRequiredForStaleLock) {
+    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);
+  }
+  await unlinkLockWithHook(lockPath, "lock:stale_remove");
+}
+async function acquireLock(pmRoot, id, ttlSeconds, owner, force = false, forceRequiredForStaleLock = true) {
+  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 releaseFromFunction = typeof lockOverride.result === "function" ? lockOverride.result : null;
+    const releaseFromObject = typeof lockOverride.result === "object" && lockOverride.result !== null && "release" in lockOverride.result && typeof lockOverride.result.release === "function" ? lockOverride.result.release : null;
+    const release = releaseFromFunction ?? releaseFromObject;
+    if (release) {
+      return async () => {
+        await Promise.resolve(release());
+        await runActiveServiceOverride("lock_release", {
+          pm_root: pmRoot,
+          id,
+          owner
+        });
+      };
+    }
+  }
+  const lockPath = getLockPath(pmRoot, id);
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    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);
+      }
+      await handleExistingLock(lockPath, id, ttlSeconds, force, forceRequiredForStaleLock);
+    }
+  }
+  throw new PmCliError(`Failed to acquire lock for ${id}`, EXIT_CODE.CONFLICT);
+}
+
+// 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);
+}
+async function loadCache(pmRoot) {
+  try {
+    const raw = await fs3.readFile(getCachePath(pmRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function loadBodyCache(pmRoot) {
+  try {
+    const raw = await fs3.readFile(getBodyCachePath(pmRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.bodies !== "object" || parsed.bodies === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function loadCollectionsCache(pmRoot) {
+  try {
+    const raw = await fs3.readFile(getCollectionsCachePath(pmRoot), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.collections !== "object" || parsed.collections === null) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function persistCache(cachePath, envelope) {
+  await fs3.mkdir(path3.dirname(cachePath), { recursive: true });
+  await writeFileAtomic(cachePath, JSON.stringify(envelope));
+}
+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 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 = existingCache && existingCache.context_fingerprint === contextFingerprint ? existingCache.entries : {};
+  const existingBodyCache = includeBody ? await loadBodyCache(pmRoot) : null;
+  const previousBodies = existingBodyCache && existingBodyCache.context_fingerprint === contextFingerprint ? existingBodyCache.bodies : {};
+  const existingCollectionsCache = includeCollections ? await loadCollectionsCache(pmRoot) : null;
+  const previousCollections = existingCollectionsCache && existingCollectionsCache.context_fingerprint === contextFingerprint ? existingCollectionsCache.collections : {};
+  const entries = Object.entries(typeToFolder);
+  const dirResults = await Promise.all(entries.map(async ([, folder]) => {
+    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: [] };
+    }
+  }));
+  const dispatchReadHooks = hasActiveOnReadHooks();
+  const newEntries = {};
+  const newBodies = {};
+  const newCollections = {};
+  const documentsById = /* @__PURE__ */ new Map();
+  let metadataMiss = false;
+  let bodyMiss = false;
+  let collectionsMiss = false;
+  const parseTasks = [];
+  for (const { folder, dirPath, files } of dirResults) {
+    for (const file of files) {
+      if (!ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext))) {
+        continue;
+      }
+      const filePath = path3.join(dirPath, file);
+      const relativePath = path3.relative(pmRoot, filePath);
+      parseTasks.push((async () => {
+        try {
+          const stat = await fs3.stat(filePath);
+          const mtimeMs = stat.mtimeMs;
+          const ctimeMs = stat.ctimeMs;
+          const { size } = stat;
+          const itemFormat = getItemFormatFromPath(filePath);
+          if (dispatchReadHooks) {
+            for (const warning of await runActiveOnReadHooks({ path: filePath, scope: "project" })) {
+              appendWarning(warnings, warning);
+            }
+          }
+          const cachedEntry = previousEntries[relativePath];
+          const metadataCached = cachedEntry !== void 0 && statMatches(cachedEntry, mtimeMs, ctimeMs, size);
+          const cachedBody = previousBodies[relativePath];
+          const bodyCached = cachedBody !== void 0 && statMatches(cachedBody, mtimeMs, ctimeMs, size);
+          const cachedCollections = previousCollections[relativePath];
+          const collectionsCached = cachedCollections !== void 0 && statMatches(cachedCollections, mtimeMs, ctimeMs, size);
+          const needRead = !metadataCached || includeBody && !bodyCached || includeCollections && !collectionsCached;
+          let lightMetadata;
+          let heavyMetadata;
+          let bodyLength;
+          let body;
+          if (needRead) {
+            const raw = await fs3.readFile(filePath, "utf8");
+            const parsed = parseItemDocument(raw, {
+              format: itemFormat,
+              schema,
+              extensionFieldNames,
+              onWarning: (w) => appendWarning(warnings, w)
+            });
+            const split = splitHeavyMetadata(parsed.metadata);
+            lightMetadata = metadataCached ? cachedEntry.metadata : split.light;
+            bodyLength = metadataCached ? cachedEntry.body_length : parsed.body.length;
+            body = includeBody ? parsed.body : void 0;
+            if (includeCollections) {
+              heavyMetadata = collectionsCached ? cachedCollections.collections : split.heavy;
+            }
+            if (!metadataCached) {
+              metadataMiss = true;
+            }
+            if (includeBody && !bodyCached) {
+              bodyMiss = true;
+            }
+            if (includeCollections && !collectionsCached) {
+              collectionsMiss = true;
+            }
+          } else {
+            lightMetadata = cachedEntry.metadata;
+            bodyLength = cachedEntry.body_length;
+            body = includeBody ? cachedBody.body : void 0;
+            heavyMetadata = includeCollections && cachedCollections ? cachedCollections.collections : void 0;
+          }
+          newEntries[relativePath] = {
+            mtime_ms: mtimeMs,
+            ctime_ms: ctimeMs,
+            size,
+            metadata: lightMetadata,
+            body_length: bodyLength
+          };
+          if (includeBody && body !== void 0) {
+            newBodies[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, body };
+          }
+          if (includeCollections && heavyMetadata !== void 0) {
+            newCollections[relativePath] = { mtime_ms: mtimeMs, ctime_ms: ctimeMs, size, collections: heavyMetadata };
+          }
+          const metadata = includeCollections ? mergeHeavyMetadata(lightMetadata, heavyMetadata) : lightMetadata;
+          const existing = documentsById.get(metadata.id);
+          const candidate = {
+            metadata,
+            body,
+            item_format: itemFormat,
+            item_path: filePath
+          };
+          if (!existing) {
+            documentsById.set(metadata.id, { candidate, itemFormat });
+          } else {
+            const shouldReplace = preferredFormat ? itemFormat === preferredFormat && existing.itemFormat !== preferredFormat : itemFormat === "toon" && existing.itemFormat !== "toon";
+            if (shouldReplace) {
+              documentsById.set(metadata.id, { candidate, itemFormat });
+            }
+          }
+        } catch {
+          appendWarning(warnings, `item_list_item_read_failed:${folder}/${file}`);
+        }
+      })());
+    }
+  }
+  await Promise.all(parseTasks);
+  const metadataDirty = metadataMiss || Object.keys(previousEntries).length !== Object.keys(newEntries).length;
+  if (metadataDirty || existingCache === null || existingCache.context_fingerprint !== contextFingerprint) {
+    await persistCache(getCachePath(pmRoot), {
+      version: CACHE_VERSION,
+      context_fingerprint: contextFingerprint,
+      entries: newEntries
+    }).catch(() => {
+    });
+  }
+  if (includeBody) {
+    const bodyDirty = bodyMiss || Object.keys(previousBodies).length !== Object.keys(newBodies).length;
+    if (bodyDirty || existingBodyCache === null || existingBodyCache.context_fingerprint !== contextFingerprint) {
+      await persistCache(getBodyCachePath(pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: contextFingerprint,
+        bodies: newBodies
+      }).catch(() => {
+      });
+    }
+  }
+  if (includeCollections) {
+    const collectionsDirty = collectionsMiss || Object.keys(previousCollections).length !== Object.keys(newCollections).length;
+    if (collectionsDirty || existingCollectionsCache === null || existingCollectionsCache.context_fingerprint !== contextFingerprint) {
+      await persistCache(getCollectionsCachePath(pmRoot), {
+        version: CACHE_VERSION,
+        context_fingerprint: contextFingerprint,
+        collections: newCollections
+      }).catch(() => {
+      });
+    }
+  }
+  return [...documentsById.values()].sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id)).map((entry) => entry.candidate);
+}
+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, 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,
+    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;
+}
+function levenshtein(a, b) {
+  if (a === b)
+    return 0;
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr.push(Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost));
+    }
+    prev = curr;
+  }
+  return prev[b.length];
+}
+async function buildDidYouMeanSuggestions(pmRoot, badId, idPrefix, typeToFolder) {
+  const normalized = normalizeItemId(badId, idPrefix);
+  const ids = await listKnownItemIds(pmRoot, typeToFolder);
+  if (ids.length === 0)
+    return [];
+  const scored = ids.map((id) => ({ id, distance: levenshtein(id, normalized) })).filter((entry) => entry.distance <= Math.max(3, Math.floor(normalized.length / 2))).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 === "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);
+  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;
+  }
+}
+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 historyPolicy = await enforceHistoryStreamPolicyForItem({
+      pmRoot: params.pmRoot,
+      settings: params.settings,
+      itemId: located.id,
+      commandLabel: params.op
+    });
+    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);
+    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
+    });
+    let effectiveTargetItemPath = targetItemPath;
+    let effectiveSerializedAfter = serializedAfter;
+    let skipItemWrite = false;
+    if (serviceWriteOverride.handled && typeof serviceWriteOverride.result === "object" && serviceWriteOverride.result !== null) {
+      const overrideRecord = serviceWriteOverride.result;
+      if (typeof overrideRecord.target_item_path === "string" && overrideRecord.target_item_path.trim().length > 0) {
+        effectiveTargetItemPath = overrideRecord.target_item_path;
+      }
+      if (typeof overrideRecord.contents === "string") {
+        effectiveSerializedAfter = overrideRecord.contents;
+      }
+      if (overrideRecord.skip_write === true) {
+        skipItemWrite = true;
+      }
+    }
+    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) {
+      if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
+        await writeFileAtomic(located.itemPath, originalRaw);
+        await fs4.rm(effectiveTargetItemPath, { force: true });
+      } else if (!skipItemWrite) {
+        await writeFileAtomic(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-GGYWB3Y2.js.map
+
+//# debugId=83aa0c1e-d8e6-5e3e-ac80-b84dd7ee7bce