@unbrained/pm-cli 2026.5.31 → 2026.6.5

package/dist/cli-bundle/chunks/{chunk-BUPWJ3IJ.js → chunk-XG7RJYHV.js}

@@ -1,21 +1,18 @@
-import {
-  acquireLock
-} from "./chunk-4AEZR5EJ.js";
 import {
   normalizeItemId,
   normalizeRawItemId
-} from "./chunk-CEFIVZPG.js";
+} from "./chunk-KA24HME7.js";
 import {
   canonicalDocument,
   parseItemDocument,
   serializeItemDocument
-} from "./chunk-MD7K4JYF.js";
+} from "./chunk-HPH6X4ZZ.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-WDPXDQFG.js";
+} from "./chunk-4PJQSECJ.js";
 import {
   nowIso
-} from "./chunk-PVNQLCIS.js";
+} from "./chunk-RANZIID5.js";
 import {
   EMPTY_CANONICAL_DOCUMENT,
   EXIT_CODE,
@@ -29,17 +26,217 @@ import {
   getHistoryPath,
   getItemFormatFromPath,
   getItemPath,
+  getLockPath,
   hasActiveOnReadHooks,
   orderObject,
   pathExists,
+  projectAfterCommandItemSnapshot,
+  recordAfterCommandAffectedItem,
   resolveGovernanceKnobs,
   runActiveOnReadHooks,
   runActiveOnWriteHooks,
   runActiveServiceOverride,
   sha256Hex,
   stableStringify,
+  toErrorMessage,
   writeFileAtomic
-} from "./chunk-LSXGH6NE.js";
+} from "./chunk-SRVKTWPR.js";
+
+// dist/core/extensions/item-fields.js
+!(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] = "60ed024d-4341-5166-bd9e-abed9b240b11");
+  } catch (e2) {
+  }
+})();
+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() {
@@ -66,17 +263,17 @@ var EMPTY_LEGACY_HASH_DOCUMENT = {
   front_matter: {},
   body: ""
 };
-function decodeJsonPointer(path4) {
-  if (!path4 || path4 === "/") {
+function decodeJsonPointer(path5) {
+  if (!path5 || path5 === "/") {
     return [];
   }
-  if (!path4.startsWith("/")) {
+  if (!path5.startsWith("/")) {
     return [];
   }
-  return path4.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+  return path5.slice(1).split("/").map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
 }
-function isDefinedPointerPath(document, path4) {
-  const segments = decodeJsonPointer(path4);
+function isDefinedPointerPath(document, path5) {
+  const segments = decodeJsonPointer(path5);
   if (segments.length === 0) {
     return true;
   }
@@ -261,14 +458,186 @@ async function enforceHistoryStreamPolicyForItems(params) {
   };
 }
 
-// dist/core/store/front-matter-cache.js
+// dist/core/lock/lock.js
 import fs2 from "node:fs/promises";
 import path2 from "node:path";
+!(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] = "5747034b-5b93-59ff-8764-7594ff8c0617");
+  } catch (e2) {
+  }
+})();
+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";
 !(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] = "a14ed5c7-eb26-57d5-8b28-58d736a3c11c");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0b313ee5-78cb-5aa7-a288-d41e3ad6ecf8");
   } catch (e2) {
   }
 })();
@@ -285,6 +654,9 @@ var HEAVY_METADATA_KEYS = [
   "test_runs",
   "docs"
 ];
+function resolveActiveExtensionFieldNames() {
+  return collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
+}
 function splitHeavyMetadata(metadata) {
   const light = { ...metadata };
   const heavy = {};
@@ -302,7 +674,7 @@ function mergeHeavyMetadata(light, heavy) {
   }
   return { ...light, ...heavy };
 }
-function computeContextFingerprint(preferredFormat, typeToFolder, schema) {
+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(",");
@@ -310,20 +682,23 @@ function computeContextFingerprint(preferredFormat, typeToFolder, schema) {
   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 path2.join(pmRoot, "runtime", CACHE_FILENAME);
+  return path3.join(pmRoot, "runtime", CACHE_FILENAME);
 }
 function getBodyCachePath(pmRoot) {
-  return path2.join(pmRoot, "runtime", BODY_CACHE_FILENAME);
+  return path3.join(pmRoot, "runtime", BODY_CACHE_FILENAME);
 }
 function getCollectionsCachePath(pmRoot) {
-  return path2.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
+  return path3.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
 }
 async function loadCache(pmRoot) {
   try {
-    const raw = await fs2.readFile(getCachePath(pmRoot), "utf8");
+    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;
@@ -335,7 +710,7 @@ async function loadCache(pmRoot) {
 }
 async function loadBodyCache(pmRoot) {
   try {
-    const raw = await fs2.readFile(getBodyCachePath(pmRoot), "utf8");
+    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;
@@ -347,7 +722,7 @@ async function loadBodyCache(pmRoot) {
 }
 async function loadCollectionsCache(pmRoot) {
   try {
-    const raw = await fs2.readFile(getCollectionsCachePath(pmRoot), "utf8");
+    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;
@@ -358,7 +733,7 @@ async function loadCollectionsCache(pmRoot) {
   }
 }
 async function persistCache(cachePath, envelope) {
-  await fs2.mkdir(path2.dirname(cachePath), { recursive: true });
+  await fs3.mkdir(path3.dirname(cachePath), { recursive: true });
   await writeFileAtomic(cachePath, JSON.stringify(envelope));
 }
 function appendWarning(warnings, warning) {
@@ -372,7 +747,8 @@ function statMatches(signature, mtimeMs, ctimeMs, size) {
 async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, options = {}) {
   const includeBody = options.includeBody !== false;
   const includeCollections = options.includeCollections !== false;
-  const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema);
+  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;
@@ -381,9 +757,9 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
   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 = path2.join(pmRoot, folder);
+    const dirPath = path3.join(pmRoot, folder);
     try {
-      const files = await fs2.readdir(dirPath);
+      const files = await fs3.readdir(dirPath);
       return { folder, dirPath, files };
     } catch (error) {
       if (typeof error === "object" && error !== null && "code" in error && error.code !== "ENOENT") {
@@ -406,11 +782,11 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
       if (!ITEM_FILE_EXTENSIONS.some((ext) => file.toLowerCase().endsWith(ext))) {
         continue;
       }
-      const filePath = path2.join(dirPath, file);
-      const relativePath = path2.relative(pmRoot, filePath);
+      const filePath = path3.join(dirPath, file);
+      const relativePath = path3.relative(pmRoot, filePath);
       parseTasks.push((async () => {
         try {
-          const stat = await fs2.stat(filePath);
+          const stat = await fs3.stat(filePath);
           const mtimeMs = stat.mtimeMs;
           const ctimeMs = stat.ctimeMs;
           const { size } = stat;
@@ -432,10 +808,11 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
           let bodyLength;
           let body;
           if (needRead) {
-            const raw = await fs2.readFile(filePath, "utf8");
+            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);
@@ -550,18 +927,18 @@ async function listAllDocumentsCachedLight(pmRoot, preferredFormat, typeToFolder
 }
 
 // dist/core/store/item-store.js
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
 !(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] = "e156425f-15da-5c83-b5e6-6c1c1271bf05");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "88895950-2871-5fe9-9c4e-04db3aada937");
   } catch (e2) {
   }
 })();
 async function fileExists(targetPath) {
   try {
-    await fs3.access(targetPath);
+    await fs4.access(targetPath);
     return true;
   } catch {
     return false;
@@ -575,6 +952,9 @@ function appendWarning2(warnings, warning) {
     warnings.push(warning);
   }
 }
+function resolveActiveExtensionFieldNames2(explicit) {
+  return explicit ?? collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
+}
 function resolveItemFormatSearchOrder(preferredFormat) {
   if (preferredFormat === "toon") {
     return ["toon", "json_markdown"];
@@ -608,7 +988,7 @@ async function locateItem(pmRoot, rawId, idPrefix, preferredFormat, typeToFolder
   return null;
 }
 async function readLocatedItem(item, options = {}) {
-  const raw = await fs3.readFile(item.itemPath, "utf8");
+  const raw = await fs4.readFile(item.itemPath, "utf8");
   await runActiveOnReadHooks({
     path: item.itemPath,
     scope: "project"
@@ -616,6 +996,7 @@ async function readLocatedItem(item, options = {}) {
   const document = parseItemDocument(raw, {
     format: item.item_format,
     schema: options.schema,
+    extensionFieldNames: resolveActiveExtensionFieldNames2(options.extensionFieldNames),
     onWarning: (warning) => appendWarning2(options.warnings, warning)
   });
   return { raw, document };
@@ -640,7 +1021,7 @@ async function listKnownItemIds(pmRoot, typeToFolder) {
   const allIds = [];
   await Promise.all([...folders].map(async (folder) => {
     try {
-      const entries = await fs3.readdir(path3.join(pmRoot, folder));
+      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)) {
@@ -702,6 +1083,7 @@ async function prepareLockedItem(params) {
     const warnings = [];
     const { raw: originalRaw, document } = await readLocatedItem(located, {
       schema: params.settings.schema,
+      extensionFieldNames: params.extensionFieldNames,
       warnings
     });
     const assigned = document.metadata.assignee?.trim();
@@ -737,6 +1119,7 @@ async function mutateItem(params) {
     author: params.author,
     force: params.force,
     bypassAssigneeConflict: params.bypassAssigneeConflict,
+    extensionFieldNames: params.extensionFieldNames,
     typeToFolder: params.typeToFolder
   });
   const { typeToFolder, located, originalRaw, document, warnings: parseWarnings, releaseLock } = prepared;
@@ -747,15 +1130,25 @@ async function mutateItem(params) {
       itemId: located.id,
       commandLabel: params.op
     });
-    const beforeDocument = canonicalDocument(document, { schema: params.settings.schema });
-    const mutableDocument = canonicalDocument(structuredClone(document), { schema: params.settings.schema });
+    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 });
+    const afterDocument = canonicalDocument(mutableDocument, {
+      schema: params.settings.schema,
+      extensionFieldNames: params.extensionFieldNames
+    });
     const targetItemFormat = "toon";
     const serializedAfter = serializeItemDocument(afterDocument, {
       format: targetItemFormat,
-      schema: params.settings.schema
+      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);
@@ -790,7 +1183,7 @@ async function mutateItem(params) {
       await writeFileAtomic(effectiveTargetItemPath, effectiveSerializedAfter);
     }
     if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
-      await fs3.rm(located.itemPath);
+      await fs4.rm(located.itemPath);
     }
     const entry = createHistoryEntry({
       nowIso: afterDocument.metadata.updated_at,
@@ -805,7 +1198,7 @@ async function mutateItem(params) {
     } catch (error) {
       if (!skipItemWrite && effectiveTargetItemPath !== located.itemPath) {
         await writeFileAtomic(located.itemPath, originalRaw);
-        await fs3.rm(effectiveTargetItemPath, { force: true });
+        await fs4.rm(effectiveTargetItemPath, { force: true });
       } else if (!skipItemWrite) {
         await writeFileAtomic(located.itemPath, originalRaw);
       }
@@ -815,14 +1208,34 @@ async function mutateItem(params) {
       ...await runActiveOnWriteHooks({
         path: effectiveTargetItemPath,
         scope: "project",
-        op: params.op
+        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`
+        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,
@@ -896,7 +1309,7 @@ async function deleteItem(params) {
       };
     }
     if (!skipDelete) {
-      await fs3.rm(effectiveItemPath);
+      await fs4.rm(effectiveItemPath);
     }
     try {
       await appendHistoryEntry(historyPath, historyEntry);
@@ -910,14 +1323,32 @@ async function deleteItem(params) {
       ...await runActiveOnWriteHooks({
         path: effectiveItemPath,
         scope: "project",
-        op: "delete"
+        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"
+        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"],
@@ -929,6 +1360,9 @@ async function deleteItem(params) {
 }
 
 export {
+  collectRegisteredItemFieldNames,
+  parseRegisteredItemFieldAssignments,
+  applyRegisteredItemFieldDefaultsAndValidation,
   toItemRecord,
   hashDocument,
   hashEmptyDocument,
@@ -936,6 +1370,7 @@ export {
   appendHistoryEntry,
   enforceHistoryStreamPolicyForItem,
   enforceHistoryStreamPolicyForItems,
+  acquireLock,
   HEAVY_METADATA_KEYS,
   listAllDocumentCandidatesCached,
   locateItem,
@@ -947,4 +1382,4 @@ export {
   mutateItem,
   deleteItem
 };
-//# sourceMappingURL=chunk-BUPWJ3IJ.js.map
+//# sourceMappingURL=chunk-XG7RJYHV.js.map