@unbrained/pm-cli 2026.7.21 → 2026.7.22

package/dist/cli-bundle/chunks/{chunk-CPX275C6.js → chunk-KPCZL2YK.js}

@@ -3,11 +3,11 @@
 import {
   readManagedExtensionState,
   runExtension
-} from "./chunk-JXCW2TI2.js";
+} from "./chunk-RPNC7M63.js";
 import {
   normalizeParentReferencePolicy,
   normalizeSprintReleaseFormatPolicy
-} from "./chunk-PEQGTJ5Q.js";
+} from "./chunk-JCLXCGIL.js";
 import {
   NESTED_SETTING_DESCRIPTORS,
   parseNestedSettingValue,
@@ -17,7 +17,7 @@ import {
 } from "./chunk-SC2HMDGB.js";
 import {
   buildInvalidTypeError
-} from "./chunk-TOBGV45Y.js";
+} from "./chunk-YUKIFPWK.js";
 import {
   getActiveExtensionRegistrations,
   parseItemDocument,
@@ -25,7 +25,7 @@ import {
   runActiveOnWriteHooks,
   serializeItemDocument,
   writeSettings
-} from "./chunk-POG76WWZ.js";
+} from "./chunk-L7DZV6EZ.js";
 import {
   CONTEXT_DEPTH_VALUES,
   EXIT_CODE,
@@ -45,7 +45,7 @@ import {
   resolvePmRoot,
   resolveTypeName,
   writeFileAtomic
-} from "./chunk-HYW67VJ5.js";
+} from "./chunk-TLF52ZDP.js";
 
 // dist/core/config/positional-value.js
 var FORMAT_KEYS = /* @__PURE__ */ new Set(["item_format"]);
@@ -1466,6 +1466,6 @@ export {
   _testOnlyConfigCommand,
   runUpgrade
 };
-//# sourceMappingURL=chunk-CPX275C6.js.map
+//# sourceMappingURL=chunk-KPCZL2YK.js.map
 
 //# debugId=5006edcd-26bd-5d8f-b7d8-dc9a71027888

package/dist/cli-bundle/chunks/{chunk-POG76WWZ.js → chunk-L7DZV6EZ.js}

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1716fd1b-596b-59b3-8dc9-1131b372683a")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="45565ba9-d014-58d6-bcd3-8134ba67451d")}catch(e){}}();
 import {
   CONFIDENCE_TEXT_VALUES,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
@@ -58,7 +58,7 @@ import {
   toErrorMessage,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-HYW67VJ5.js";
+} from "./chunk-TLF52ZDP.js";
 
 // dist/core/extensions/command-hook-context.js
 function createCoreCommandHookContext(options) {
@@ -1925,7 +1925,12 @@ async function readSettingsWithMetadata(pmRoot) {
   const settingsOnlySignatures = await collectSettingsReadCacheSignatures([
     settingsPath
   ]);
-  const raw = await readFileIfExists(settingsPath);
+  let raw;
+  try {
+    raw = await readFileIfExists(settingsPath);
+  } catch {
+    return buildFallbackSettingsReadResult("settings_read_fs_error");
+  }
   if (raw === null) {
     const fallback = buildFallbackSettingsReadResult();
     await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsOnlySignatures, [settingsPath]);
@@ -4398,19 +4403,18 @@ async function generateItemId(pmRoot, prefix, options = {}) {
   throw new Error(`Unable to generate unique id after ${attempts} attempts`);
 }
 
-// dist/core/store/item-store.js
-import fs4 from "node:fs/promises";
-import path5 from "node:path";
-
 // dist/core/store/item-metadata-cache.js
 import fs3 from "node:fs/promises";
 import path4 from "node:path";
-import { createHash } from "node:crypto";
-var CACHE_VERSION = 7;
-var DEFAULT_DERIVED_INDEX_MINIMUM_ITEMS = 1e4;
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+var CACHE_VERSION = 8;
+var DEFAULT_DERIVED_INDEX_MINIMUM_ITEMS = 500;
+var DERIVED_INDEX_LOCK_ID = "metadata-derived-index";
 var CACHE_FILENAME = "metadata-cache.json";
 var BODY_CACHE_FILENAME = "metadata-cache-bodies.json";
 var COLLECTIONS_CACHE_FILENAME = "metadata-cache-collections.json";
+var DELTA_CACHE_FILENAME = "metadata-cache-delta.json";
+var MANIFEST_CACHE_FILENAME = "metadata-cache-manifest.json";
 var HEAVY_METADATA_KEYS = [
   "comments",
   "notes",
@@ -4462,8 +4466,73 @@ function getBodyCachePath(pmRoot) {
 function getCollectionsCachePath(pmRoot) {
   return path4.join(pmRoot, "runtime", COLLECTIONS_CACHE_FILENAME);
 }
+function getDeltaCachePath(pmRoot) {
+  return path4.join(pmRoot, "runtime", DELTA_CACHE_FILENAME);
+}
+function getManifestCachePath(pmRoot) {
+  return path4.join(pmRoot, "runtime", MANIFEST_CACHE_FILENAME);
+}
 var ENVELOPE_MEMO_MAX_ENTRIES = 24;
 var envelopeMemo = /* @__PURE__ */ new Map();
+var projectedBaseCursor = /* @__PURE__ */ new WeakMap();
+function baseCursorFor(envelope) {
+  return projectedBaseCursor.get(envelope) ?? envelope.source_cursor;
+}
+function applyMetadataDelta(envelope, delta) {
+  const baseCursor = baseCursorFor(envelope);
+  if (delta.base_source_cursor !== baseCursor || envelope.source_cursor === delta.source_cursor) {
+    return;
+  }
+  projectedBaseCursor.set(envelope, baseCursor);
+  for (const [relativePath, change] of Object.entries(delta.changes)) {
+    if (change.entry)
+      envelope.entries[relativePath] = change.entry;
+    else
+      delete envelope.entries[relativePath];
+  }
+  envelope.directory_signatures = delta.directory_signatures;
+  envelope.source_cursor = delta.source_cursor;
+}
+function applyBodyDelta(envelope, delta) {
+  if (!envelope)
+    return;
+  const baseCursor = baseCursorFor(envelope);
+  if (delta.base_source_cursor !== baseCursor || envelope.source_cursor === delta.source_cursor) {
+    return;
+  }
+  projectedBaseCursor.set(envelope, baseCursor);
+  for (const [relativePath, change] of Object.entries(delta.changes)) {
+    if (change.body)
+      envelope.bodies[relativePath] = change.body;
+    else
+      delete envelope.bodies[relativePath];
+  }
+  envelope.source_cursor = delta.source_cursor;
+}
+function applyCollectionsDelta(envelope, delta) {
+  if (!envelope)
+    return;
+  const baseCursor = baseCursorFor(envelope);
+  if (delta.base_source_cursor !== baseCursor || envelope.source_cursor === delta.source_cursor) {
+    return;
+  }
+  projectedBaseCursor.set(envelope, baseCursor);
+  for (const [relativePath, change] of Object.entries(delta.changes)) {
+    if (change.collections)
+      envelope.collections[relativePath] = change.collections;
+    else
+      delete envelope.collections[relativePath];
+  }
+  envelope.source_cursor = delta.source_cursor;
+}
+function applyDerivedIndexDelta(metadata, bodies, collections, delta) {
+  if (!metadata || !delta || metadata.context_fingerprint !== delta.context_fingerprint) {
+    return;
+  }
+  applyMetadataDelta(metadata, delta);
+  applyBodyDelta(bodies, delta);
+  applyCollectionsDelta(collections, delta);
+}
 function memoizeEnvelope(cachePath, entry) {
   if (envelopeMemo.size >= ENVELOPE_MEMO_MAX_ENTRIES && !envelopeMemo.has(cachePath)) {
     evictOldestMemoEntries(envelopeMemo);
@@ -4503,7 +4572,7 @@ async function loadEnvelopeMemoized(cachePath, parse) {
 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) {
+    if (parsed.version !== CACHE_VERSION || typeof parsed.source_cursor !== "string" || typeof parsed.entries !== "object" || parsed.entries === null) {
       return null;
     }
     return parsed;
@@ -4512,7 +4581,7 @@ async function loadCache(pmRoot) {
 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) {
+    if (parsed.version !== CACHE_VERSION || typeof parsed.source_cursor !== "string" || typeof parsed.bodies !== "object" || parsed.bodies === null) {
       return null;
     }
     return parsed;
@@ -4521,12 +4590,48 @@ async function loadBodyCache(pmRoot) {
 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) {
+    if (parsed.version !== CACHE_VERSION || typeof parsed.source_cursor !== "string" || typeof parsed.collections !== "object" || parsed.collections === null) {
       return null;
     }
     return parsed;
   });
 }
+async function loadDerivedIndexDelta(pmRoot) {
+  const deltaPath = getDeltaCachePath(pmRoot);
+  const envelope = await loadEnvelopeMemoized(deltaPath, (raw) => {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.base_source_cursor !== "string" || typeof parsed.source_cursor !== "string" || typeof parsed.changes !== "object" || parsed.changes === null) {
+      return null;
+    }
+    return parsed;
+  });
+  if (envelope)
+    return { envelope, invalid: false };
+  try {
+    await fs3.stat(deltaPath);
+    return { envelope: null, invalid: true };
+  } catch {
+    return { envelope: null, invalid: false };
+  }
+}
+async function loadDerivedIndexManifest(pmRoot) {
+  const manifestPath = getManifestCachePath(pmRoot);
+  const manifest = await loadEnvelopeMemoized(manifestPath, (raw) => {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.context_fingerprint !== "string" || typeof parsed.source_cursor !== "string" || !Number.isInteger(parsed.entry_count) || parsed.entry_count < 0) {
+      return null;
+    }
+    return parsed;
+  });
+  if (manifest)
+    return manifest;
+  try {
+    await fs3.stat(manifestPath);
+    await removeDerivedIndexFiles(pmRoot);
+  } catch {
+  }
+  return null;
+}
 async function persistCache(cachePath, envelope) {
   await fs3.mkdir(path4.dirname(cachePath), { recursive: true });
   await writeFileAtomic(cachePath, JSON.stringify(envelope));
@@ -4586,10 +4691,7 @@ async function readDirectorySignature(pmRoot, folder) {
       }
     ];
   } catch {
-    return [
-      folder,
-      { exists: false, mtime_ms: 0, ctime_ms: 0, size: 0 }
-    ];
+    return [folder, { exists: false, mtime_ms: 0, ctime_ms: 0, size: 0 }];
   }
 }
 async function readDirectorySignatures(pmRoot, folders) {
@@ -4769,13 +4871,22 @@ async function persistMetadataCacheIfNeeded(params) {
   if (!metadataDirty && params.existingCache !== null && params.existingCache.context_fingerprint === params.contextFingerprint) {
     return;
   }
-  await persistCache(getCachePath(params.pmRoot), {
-    version: CACHE_VERSION,
-    context_fingerprint: params.contextFingerprint,
-    directory_signatures: params.directorySignatures,
-    entries: params.state.newEntries
-  }).catch(() => {
-  });
+  try {
+    await persistCache(getCachePath(params.pmRoot), {
+      version: CACHE_VERSION,
+      context_fingerprint: params.contextFingerprint,
+      source_cursor: params.sourceCursor,
+      directory_signatures: params.directorySignatures,
+      entries: params.state.newEntries
+    });
+    await persistCache(getManifestCachePath(params.pmRoot), {
+      version: CACHE_VERSION,
+      context_fingerprint: params.contextFingerprint,
+      source_cursor: params.sourceCursor,
+      entry_count: Object.keys(params.state.newEntries).length
+    });
+  } catch {
+  }
 }
 async function persistBodyCacheIfNeeded(params) {
   const bodyDirty = params.state.misses.body || Object.keys(params.previousBodies).length !== Object.keys(params.state.newBodies).length;
@@ -4785,6 +4896,7 @@ async function persistBodyCacheIfNeeded(params) {
   await persistCache(getBodyCachePath(params.pmRoot), {
     version: CACHE_VERSION,
     context_fingerprint: params.contextFingerprint,
+    source_cursor: params.sourceCursor,
     bodies: params.state.newBodies
   }).catch(() => {
   });
@@ -4797,15 +4909,112 @@ async function persistCollectionsCacheIfNeeded(params) {
   await persistCache(getCollectionsCachePath(params.pmRoot), {
     version: CACHE_VERSION,
     context_fingerprint: params.contextFingerprint,
+    source_cursor: params.sourceCursor,
     collections: params.state.newCollections
   }).catch(() => {
   });
 }
+async function acquireItemMetadataDerivedIndexLock(pmRoot, author) {
+  const cache = await loadDerivedIndexManifest(pmRoot);
+  if (cache === null || cache.entry_count < DEFAULT_DERIVED_INDEX_MINIMUM_ITEMS) {
+    return async () => {
+    };
+  }
+  return acquireLock(pmRoot, DERIVED_INDEX_LOCK_ID, 30, author, false, false, 3e3);
+}
+function relativeIndexPath(pmRoot, itemPath) {
+  const relative = path4.relative(pmRoot, itemPath);
+  return relative === "" || relative === ".." || relative.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative) ? null : relative;
+}
+async function removeDerivedIndexFiles(pmRoot) {
+  await Promise.all([
+    getCachePath(pmRoot),
+    getBodyCachePath(pmRoot),
+    getCollectionsCachePath(pmRoot),
+    getDeltaCachePath(pmRoot),
+    getManifestCachePath(pmRoot)
+  ].map(async (cachePath) => {
+    await fs3.rm(cachePath, { force: true });
+    envelopeMemo.delete(cachePath);
+  }));
+}
+async function createDerivedIndexDeltaChange(params) {
+  if (params.mutation.document === null) {
+    return { entry: null, body: null, collections: null };
+  }
+  const stat2 = await fs3.stat(params.mutation.itemPath);
+  const split = splitHeavyMetadata(params.mutation.document.metadata);
+  const signature = {
+    mtime_ms: stat2.mtimeMs,
+    ctime_ms: stat2.ctimeMs,
+    size: stat2.size
+  };
+  return {
+    entry: {
+      ...signature,
+      metadata: split.light,
+      body_length: params.mutation.document.body.length
+    },
+    body: { ...signature, body: params.mutation.document.body },
+    collections: {
+      ...signature,
+      collections: split.heavy
+    }
+  };
+}
+function selectDerivedIndexDeltaChanges(delta, contextFingerprint, baseSourceCursor) {
+  return delta?.context_fingerprint === contextFingerprint && delta.base_source_cursor === baseSourceCursor ? structuredClone(delta.changes) : {};
+}
+async function refreshItemMetadataDerivedIndex(mutation) {
+  const relativePath = relativeIndexPath(mutation.pmRoot, mutation.itemPath);
+  const previousRelativePath = mutation.previousItemPath ? relativeIndexPath(mutation.pmRoot, mutation.previousItemPath) : void 0;
+  if (relativePath === null || previousRelativePath === null) {
+    await removeDerivedIndexFiles(mutation.pmRoot);
+    return ["metadata_derived_index_path_invalidated"];
+  }
+  try {
+    const contextFingerprint = computeContextFingerprint(mutation.preferredFormat, mutation.typeToFolder, mutation.schema, resolveActiveExtensionFieldNames());
+    const existingCache = await loadDerivedIndexManifest(mutation.pmRoot);
+    if (existingCache === null || existingCache.context_fingerprint !== contextFingerprint) {
+      return [];
+    }
+    const baseSourceCursor = existingCache.source_cursor;
+    const delta = await loadDerivedIndexDelta(mutation.pmRoot);
+    if (delta.invalid) {
+      await removeDerivedIndexFiles(mutation.pmRoot);
+      return ["metadata_derived_index_refresh_failed"];
+    }
+    const changes = selectDerivedIndexDeltaChanges(delta.envelope, contextFingerprint, baseSourceCursor);
+    if (previousRelativePath !== void 0) {
+      changes[previousRelativePath] = {
+        entry: null,
+        body: null,
+        collections: null
+      };
+    }
+    changes[relativePath] = await createDerivedIndexDeltaChange({ mutation });
+    await persistCache(getDeltaCachePath(mutation.pmRoot), {
+      version: CACHE_VERSION,
+      context_fingerprint: contextFingerprint,
+      base_source_cursor: baseSourceCursor,
+      source_cursor: randomUUID2(),
+      directory_signatures: await readDirectorySignatures(mutation.pmRoot, [
+        ...new Set(Object.values(mutation.typeToFolder))
+      ]),
+      changes
+    });
+    return [];
+  } catch {
+    await removeDerivedIndexFiles(mutation.pmRoot).catch(() => {
+    });
+    return ["metadata_derived_index_refresh_failed"];
+  }
+}
 function sortedCachedDocumentCandidates(state) {
   return [...state.documentsById.values()].sort((left, right) => left.candidate.metadata.id.localeCompare(right.candidate.metadata.id)).map((entry) => entry.candidate);
 }
-function cacheTierMatchesContext(envelope, contextFingerprint) {
-  return envelope?.context_fingerprint === contextFingerprint;
+function cacheTierMatchesContext(envelope, contextFingerprint, sourceCursor) {
+  return envelope?.context_fingerprint === contextFingerprint && envelope.source_cursor === sourceCursor;
 }
 function hasEveryDerivedIndexPart(keys, includeBody, includeCollections, previousBodies, previousCollections) {
   return keys.every((key) => (!includeBody || previousBodies[key] !== void 0) && (!includeCollections || previousCollections[key] !== void 0));
@@ -4838,8 +5047,8 @@ function canUseDerivedIndex(params) {
     return false;
   }
   const requiredTiersMatch = [
-    !params.includeBody || cacheTierMatchesContext(params.existingBodyCache, params.contextFingerprint),
-    !params.includeCollections || cacheTierMatchesContext(params.existingCollectionsCache, params.contextFingerprint)
+    !params.includeBody || cacheTierMatchesContext(params.existingBodyCache, params.contextFingerprint, params.existingCache.source_cursor),
+    !params.includeCollections || cacheTierMatchesContext(params.existingCollectionsCache, params.contextFingerprint, params.existingCache.source_cursor)
   ];
   return requiredTiersMatch.every(Boolean) && hasEveryDerivedIndexPart(params.entryKeys, params.includeBody, params.includeCollections, params.previousBodies, params.previousCollections);
 }
@@ -4848,11 +5057,15 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
   const includeCollections = options.includeCollections !== false;
   const extensionFieldNames = resolveActiveExtensionFieldNames();
   const contextFingerprint = computeContextFingerprint(preferredFormat, typeToFolder, schema, extensionFieldNames);
+  const delta = await loadDerivedIndexDelta(pmRoot);
+  if (delta.invalid)
+    await removeDerivedIndexFiles(pmRoot);
   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;
+  applyDerivedIndexDelta(existingCache, existingBodyCache, existingCollectionsCache, delta.envelope);
+  const previousEntries = selectPreviousMetadataEntries(existingCache, contextFingerprint);
+  const previousBodies = selectPreviousBodyEntries(existingBodyCache, contextFingerprint);
   const previousCollections = selectPreviousCollectionEntries(existingCollectionsCache, contextFingerprint);
   const folders = [...new Set(Object.values(typeToFolder))];
   const directorySignaturesBefore = await readDirectorySignatures(pmRoot, folders);
@@ -4902,9 +5115,12 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
   await Promise.all(collectCachedDocumentParseTasks(dirResults, context));
   const directorySignaturesAfter = await readDirectorySignatures(pmRoot, folders);
   const stableDirectorySignatures = directorySignaturesMatch(directorySignaturesBefore, directorySignaturesAfter) ? directorySignaturesAfter : {};
+  const metadataChanged = state.misses.metadata || Object.keys(previousEntries).length !== Object.keys(state.newEntries).length || !directorySignaturesMatch(existingCache?.directory_signatures, stableDirectorySignatures);
+  const sourceCursor = metadataChanged || existingCache === null ? randomUUID2() : existingCache.source_cursor;
   await persistMetadataCacheIfNeeded({
     pmRoot,
     contextFingerprint,
+    sourceCursor,
     existingCache,
     previousEntries,
     directorySignatures: stableDirectorySignatures,
@@ -4914,6 +5130,7 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
     await persistBodyCacheIfNeeded({
       pmRoot,
       contextFingerprint,
+      sourceCursor,
       existingBodyCache,
       previousBodies,
       state
@@ -4923,6 +5140,7 @@ async function listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFo
     await persistCollectionsCacheIfNeeded({
       pmRoot,
       contextFingerprint,
+      sourceCursor,
       existingCollectionsCache,
       previousCollections,
       state
@@ -4951,6 +5169,8 @@ async function listAllDocumentsCachedLight(pmRoot, preferredFormat, typeToFolder
 }
 
 // dist/core/store/item-store.js
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
 async function fileExists(targetPath) {
   try {
     await fs4.access(targetPath);
@@ -5207,30 +5427,47 @@ async function mutateItem(params) {
       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
-    });
+    const releaseDerivedIndexLock = await acquireItemMetadataDerivedIndexLock(params.pmRoot, params.author);
+    let derivedIndexWarnings = [];
     try {
-      await appendHistoryEntry(historyPath, entry);
-    } catch (error) {
-      await rollbackMutatedItemWrite({
-        skipItemWrite,
-        effectiveTargetItemPath,
-        originalItemPath: located.itemPath,
-        originalRaw
+      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
       });
-      throw error;
+      try {
+        await appendHistoryEntry(historyPath, entry);
+      } catch (error) {
+        await rollbackMutatedItemWrite({
+          skipItemWrite,
+          effectiveTargetItemPath,
+          originalItemPath: located.itemPath,
+          originalRaw
+        });
+        throw error;
+      }
+      if (!skipItemWrite) {
+        derivedIndexWarnings = await refreshItemMetadataDerivedIndex({
+          pmRoot: params.pmRoot,
+          preferredFormat: params.settings.item_format,
+          typeToFolder,
+          schema: params.settings.schema,
+          itemPath: effectiveTargetItemPath,
+          previousItemPath: located.itemPath,
+          document: afterDocument
+        });
+      }
+    } finally {
+      await releaseDerivedIndexLock();
     }
     const hookWarnings = [
       ...await runActiveOnWriteHooks({
@@ -5273,6 +5510,7 @@ async function mutateItem(params) {
         ...mutation.warnings ?? [],
         ...historyPolicy.warnings,
         ...serviceWriteOverride.warnings,
+        ...derivedIndexWarnings,
         ...hookWarnings
       ]
     };
@@ -5342,16 +5580,32 @@ async function deleteItem(params) {
         ]
       };
     }
-    if (!skipDelete) {
-      await fs4.rm(effectiveItemPath);
-    }
+    const releaseDerivedIndexLock = await acquireItemMetadataDerivedIndexLock(params.pmRoot, params.author);
+    let derivedIndexWarnings = [];
     try {
-      await appendHistoryEntry(historyPath, historyEntry);
-    } catch (error) {
       if (!skipDelete) {
-        await writeFileAtomic(effectiveItemPath, originalRaw);
+        await fs4.rm(effectiveItemPath);
+      }
+      try {
+        await appendHistoryEntry(historyPath, historyEntry);
+      } catch (error) {
+        if (!skipDelete) {
+          await writeFileAtomic(effectiveItemPath, originalRaw);
+        }
+        throw error;
+      }
+      if (!skipDelete) {
+        derivedIndexWarnings = await refreshItemMetadataDerivedIndex({
+          pmRoot: params.pmRoot,
+          preferredFormat: params.settings.item_format,
+          typeToFolder: prepared.typeToFolder,
+          schema: params.settings.schema,
+          itemPath: effectiveItemPath,
+          document: null
+        });
       }
-      throw error;
+    } finally {
+      await releaseDerivedIndexLock();
     }
     const hookWarnings = [
       ...await runActiveOnWriteHooks({
@@ -5390,6 +5644,7 @@ async function deleteItem(params) {
         ...parseWarnings,
         ...historyPolicy.warnings,
         ...serviceDeleteOverride.warnings,
+        ...derivedIndexWarnings,
         ...hookWarnings
       ]
     };
@@ -5472,7 +5727,10 @@ export {
   normalizeRawItemId,
   normalizeItemId,
   generateItemId,
+  DEFAULT_DERIVED_INDEX_MINIMUM_ITEMS,
   HEAVY_METADATA_KEYS,
+  acquireItemMetadataDerivedIndexLock,
+  refreshItemMetadataDerivedIndex,
   listAllDocumentCandidatesCached,
   locateItem,
   readLocatedItem,
@@ -5483,6 +5741,6 @@ export {
   mutateItem,
   deleteItem
 };
-//# sourceMappingURL=chunk-POG76WWZ.js.map
+//# sourceMappingURL=chunk-L7DZV6EZ.js.map
 
-//# debugId=1716fd1b-596b-59b3-8dc9-1131b372683a
+//# debugId=45565ba9-d014-58d6-bcd3-8134ba67451d