@unbrained/pm-cli 2026.6.9 → 2026.6.11

package/dist/cli-bundle/chunks/{chunk-5JF76OJF.js → chunk-A6LXQFO7.js}

@@ -1,6 +1,6 @@
 // dist/core/fs/fs-utils.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]="fb874b51-e242-55eb-aa06-2173035fe85d")}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]="3d81dd28-0239-582e-84cb-25d9dea99250")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -158,6 +158,7 @@ var EXTENSION_CAPABILITY_CONTRACT = Object.freeze({
 var KNOWN_EXTENSION_POLICY_MODES = ["off", "warn", "enforce"];
 var KNOWN_EXTENSION_TRUST_MODES = ["off", "warn", "enforce"];
 var KNOWN_EXTENSION_SANDBOX_PROFILES = ["none", "restricted", "strict"];
+var KNOWN_PM_MAX_VERSION_EXCEEDED_MODES = ["block", "warn"];
 var KNOWN_EXTENSION_POLICY_SURFACES = [
   "commands.override",
   "commands.handler",
@@ -211,6 +212,23 @@ function createDefaultExtensionGovernancePolicy() {
     extension_overrides: []
   };
 }
+var KNOWN_EXTENSION_MANIFEST_FIELDS = Object.freeze([
+  "$schema",
+  "name",
+  "version",
+  "entry",
+  "priority",
+  "manifest_version",
+  "pm_min_version",
+  "pm_max_version",
+  "engines",
+  "trusted",
+  "provenance",
+  "sandbox_profile",
+  "permissions",
+  "capabilities",
+  "activation"
+]);
 
 // dist/core/shared/constants.js
 var DEFAULT_STATUS_DEFINITIONS = Object.freeze([
@@ -347,6 +365,7 @@ var FRONT_MATTER_KEY_ORDER = [
   "test_runs",
   "docs",
   "close_reason",
+  "duplicate_of",
   "plan_mode",
   "plan_scope",
   "plan_harness",
@@ -362,7 +381,7 @@ var GOVERNANCE_PRESET_DEFAULTS = {
     create_mode_default: "progressive",
     close_validation_default: "off",
     require_close_reason: true,
-    parent_reference: "warn",
+    parent_reference: "strict_error",
     metadata_profile: "core",
     force_required_for_stale_lock: false
   },
@@ -371,7 +390,7 @@ var GOVERNANCE_PRESET_DEFAULTS = {
     create_mode_default: "progressive",
     close_validation_default: "warn",
     require_close_reason: true,
-    parent_reference: "warn",
+    parent_reference: "strict_error",
     metadata_profile: "core",
     force_required_for_stale_lock: true
   },
@@ -516,6 +535,8 @@ var SETTINGS_DEFAULTS = {
       hierarchy: true,
       activity: true,
       progress: true,
+      recently_created: true,
+      unparented: true,
       blockers: true,
       files: true,
       workload: true,
@@ -553,6 +574,7 @@ var TELEMETRY_ERROR_CATEGORY_BY_CODE = Object.freeze({
   missing_required_option: "usage",
   missing_required_argument: "usage",
   invalid_command_usage: "usage",
+  linked_test_value_not_quoted: "usage",
   invalid_argument_value: "validation",
   health_findings: "validation",
   validation_findings: "validation",
@@ -1574,6 +1596,29 @@ function normalizePolicySandboxProfile(value) {
   }
   return "none";
 }
+function normalizePmMaxVersionExceededModeValue(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  return KNOWN_PM_MAX_VERSION_EXCEEDED_MODES.includes(normalized) ? normalized : void 0;
+}
+function normalizePmMaxVersionExceededMode(value) {
+  if (typeof value === "string") {
+    const mode = normalizePmMaxVersionExceededModeValue(value) ?? "block";
+    return { global: mode, project: mode };
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return {
+      global: normalizePmMaxVersionExceededModeValue(value.global) ?? "block",
+      project: normalizePmMaxVersionExceededModeValue(value.project) ?? "block"
+    };
+  }
+  return { global: "block", project: "block" };
+}
+function serializePmMaxVersionExceededMode(mode) {
+  return mode.global === mode.project ? mode.global : { global: mode.global, project: mode.project };
+}
 function toSortedList(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
@@ -1617,6 +1662,7 @@ function normalizeExtensionPolicy(settings) {
   const policy = settings.extensions.policy;
   const mode = normalizePolicyMode(policy?.mode);
   const trustMode = normalizePolicyTrustMode(policy?.trust_mode);
+  const pmMaxVersionExceededMode2 = normalizePmMaxVersionExceededMode(policy?.pm_max_version_exceeded_mode);
   const requireProvenance = policy?.require_provenance === true;
   const trustedExtensions = normalizePolicyStringSet(policy?.trusted_extensions);
   const defaultSandboxProfile = normalizePolicySandboxProfile(policy?.default_sandbox_profile);
@@ -1662,6 +1708,7 @@ function normalizeExtensionPolicy(settings) {
   return {
     mode,
     trustMode,
+    pmMaxVersionExceededMode: pmMaxVersionExceededMode2,
     requireProvenance,
     trustedExtensions,
     defaultSandboxProfile,
@@ -1702,6 +1749,7 @@ function serializeExtensionPolicy(policy) {
   return {
     mode: policy.mode,
     trust_mode: policy.trustMode,
+    pm_max_version_exceeded_mode: serializePmMaxVersionExceededMode(policy.pmMaxVersionExceededMode),
     require_provenance: policy.requireProvenance,
     trusted_extensions: toSortedList(policy.trustedExtensions),
     default_sandbox_profile: policy.defaultSandboxProfile,
@@ -1725,6 +1773,7 @@ function hydrateExtensionPolicy(policy) {
   return {
     mode: normalizePolicyMode(policy.mode),
     trustMode: normalizePolicyTrustMode(policy.trust_mode),
+    pmMaxVersionExceededMode: normalizePmMaxVersionExceededMode(policy.pm_max_version_exceeded_mode),
     requireProvenance: policy.require_provenance === true,
     trustedExtensions: normalizePolicyStringSet(policy.trusted_extensions),
     defaultSandboxProfile: normalizePolicySandboxProfile(policy.default_sandbox_profile),
@@ -2298,14 +2347,14 @@ function buildEffectiveExtensions(globalCandidates, projectCandidates) {
   }
   return effective;
 }
-async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled) {
+async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled, pmMaxVersionExceededMode2) {
   const diagnostics = [];
   const warnings = [];
   const candidates = [];
   const directories = await listExtensionDirectories(extensionsRoot);
   const managedSourcePackages = await readManagedExtensionSourcePackages(extensionsRoot);
   for (const directory of directories) {
-    const scanned = await scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages);
+    const scanned = await scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages, pmMaxVersionExceededMode2);
     diagnostics.push(scanned.diagnostic);
     warnings.push(...scanned.warnings);
     if (scanned.candidate) {
@@ -2314,7 +2363,7 @@ async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled) {
   }
   return { diagnostics, warnings, candidates };
 }
-async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages) {
+async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages, pmMaxVersionExceededMode2) {
   const extensionDir = path5.join(extensionsRoot, directory);
   const manifestPath = path5.join(extensionDir, "manifest.json");
   if (!await pathExists(manifestPath)) {
@@ -2381,7 +2430,7 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
   if (pmVersionCompatibility.warning) {
     extensionWarnings.push(pmVersionCompatibility.warning);
   }
-  const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest);
+  const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest, pmMaxVersionExceededMode2);
   if (pmMaxVersionCompatibility.warning) {
     extensionWarnings.push(pmMaxVersionCompatibility.warning);
   }
@@ -2431,8 +2480,8 @@ async function discoverExtensions(options) {
   }
   const enabled = new Set(configured_enabled);
   const disabled = new Set(configured_disabled);
-  const globalScan = await scanExtensionLayer("global", roots.global, enabled, disabled);
-  const projectScan = await scanExtensionLayer("project", roots.project, enabled, disabled);
+  const globalScan = await scanExtensionLayer("global", roots.global, enabled, disabled, policy.pmMaxVersionExceededMode.global);
+  const projectScan = await scanExtensionLayer("project", roots.project, enabled, disabled, policy.pmMaxVersionExceededMode.project);
   const policyWarnings = [...policy.warnings];
   const effectiveCandidates = buildEffectiveExtensions(globalScan.candidates, projectScan.candidates);
   const effective = [];
@@ -2557,7 +2606,7 @@ async function evaluatePmMinVersionCompatibility(layer, manifest) {
   }
   return { allowed: true };
 }
-async function evaluatePmMaxVersionCompatibility(layer, manifest) {
+async function evaluatePmMaxVersionCompatibility(layer, manifest, exceededMode) {
   if (typeof manifest.pm_max_version !== "string" || manifest.pm_max_version.trim().length === 0) {
     return { allowed: true };
   }
@@ -2588,6 +2637,12 @@ async function evaluatePmMaxVersionCompatibility(layer, manifest) {
     };
   }
   if (comparison > 0) {
+    if (exceededMode === "warn") {
+      return {
+        allowed: true,
+        warning: `extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
+      };
+    }
     return {
       allowed: false,
       warning: `extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
@@ -4075,6 +4130,8 @@ var CONTEXT_SECTION_VALUES = [
   "hierarchy",
   "activity",
   "progress",
+  "recently_created",
+  "unparented",
   "blockers",
   "files",
   "workload",
@@ -4982,9 +5039,15 @@ var extensionPolicyOverride = vObject({
   allowed_services: vOptional(vArray(vString)),
   blocked_services: vOptional(vArray(vString))
 });
+var pmMaxVersionExceededModeLiteral = vLiteral("block", "warn");
+var pmMaxVersionExceededMode = (input) => typeof input === "string" ? pmMaxVersionExceededModeLiteral(input) : vObject({
+  global: vOptional(pmMaxVersionExceededModeLiteral),
+  project: vOptional(pmMaxVersionExceededModeLiteral)
+})(input);
 var extensionPolicy = vOptional(vObject({
   mode: vOptional(vLiteral("off", "warn", "enforce")),
   trust_mode: vOptional(vLiteral("off", "warn", "enforce")),
+  pm_max_version_exceeded_mode: vOptional(pmMaxVersionExceededMode),
   require_provenance: vOptional(vBoolean),
   trusted_extensions: vOptional(vArray(vString)),
   default_sandbox_profile: vOptional(vLiteral("none", "restricted", "strict")),
@@ -5048,6 +5111,8 @@ var settingsCheck = vObject({
       hierarchy: vOptional(vBoolean),
       activity: vOptional(vBoolean),
       progress: vOptional(vBoolean),
+      recently_created: vOptional(vBoolean),
+      unparented: vOptional(vBoolean),
       blockers: vOptional(vBoolean),
       files: vOptional(vBoolean),
       workload: vOptional(vBoolean),
@@ -5181,6 +5246,71 @@ function normalizeItemTypeDefinition(definition, options = {}) {
   };
 }
 
+// dist/core/store/settings-read-cache.js
+import { stat } from "node:fs/promises";
+var settingsReadCacheByRoot = /* @__PURE__ */ new Map();
+function normalizeTrackedPaths(paths) {
+  return [...new Set(paths.map((pathValue) => pathValue.trim()).filter((pathValue) => pathValue.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+async function readPathSignature(targetPath) {
+  try {
+    const targetStats = await stat(targetPath);
+    return {
+      path: targetPath,
+      mtime_ms: targetStats.mtimeMs,
+      size: targetStats.size
+    };
+  } catch {
+    return {
+      path: targetPath,
+      mtime_ms: null,
+      size: null
+    };
+  }
+}
+async function collectSettingsReadCacheSignatures(paths) {
+  const normalizedPaths = normalizeTrackedPaths(paths);
+  const signatures = await Promise.all(normalizedPaths.map((targetPath) => readPathSignature(targetPath)));
+  signatures.sort((left, right) => left.path.localeCompare(right.path));
+  return signatures;
+}
+function settingsReadCacheSignaturesEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    const leftEntry = left[index];
+    const rightEntry = right[index];
+    if (leftEntry.path !== rightEntry.path || leftEntry.mtime_ms !== rightEntry.mtime_ms || leftEntry.size !== rightEntry.size) {
+      return false;
+    }
+  }
+  return true;
+}
+function getSettingsReadCacheEntry(pmRoot) {
+  return settingsReadCacheByRoot.get(pmRoot);
+}
+function setSettingsReadCacheEntry(pmRoot, entry) {
+  const normalizedTrackedPaths = normalizeTrackedPaths(entry.tracked_paths);
+  const normalizedSignatures = [...entry.signatures].map((signature) => ({
+    path: signature.path,
+    mtime_ms: signature.mtime_ms,
+    size: signature.size
+  })).sort((left, right) => left.path.localeCompare(right.path));
+  settingsReadCacheByRoot.set(pmRoot, {
+    tracked_paths: normalizedTrackedPaths,
+    signatures: normalizedSignatures,
+    value: entry.value
+  });
+}
+function clearSettingsReadCache(pmRoot) {
+  if (pmRoot) {
+    settingsReadCacheByRoot.delete(pmRoot);
+    return;
+  }
+  settingsReadCacheByRoot.clear();
+}
+
 // dist/core/store/settings.js
 var SETTINGS_WRITE_OP = "settings:write";
 var SETTINGS_PERSIST_SOURCE_SYMBOL = /* @__PURE__ */ Symbol("pm.settings.persist_source");
@@ -5347,6 +5477,74 @@ function getSettingsPersistSourceSnapshot(settings) {
   }
   return candidate;
 }
+function cloneSettingsReadResult(result) {
+  const clonedSettings = structuredClone(result.settings);
+  const persistSource = getSettingsPersistSourceSnapshot(result.settings);
+  if (persistSource) {
+    attachSettingsPersistSourceSnapshot(clonedSettings, structuredClone(persistSource));
+  }
+  return {
+    settings: clonedSettings,
+    metadata: {
+      has_explicit_item_format: result.metadata.has_explicit_item_format
+    },
+    warnings: [...result.warnings]
+  };
+}
+function resolveSettingsReadTrackedPaths(pmRoot, schema, settingsPath) {
+  const normalizedSchema = normalizeRuntimeSchemaSettings(schema);
+  return [
+    settingsPath,
+    filePathForSchemaSection(pmRoot, normalizedSchema.files.types, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.types),
+    filePathForSchemaSection(pmRoot, normalizedSchema.files.statuses, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.statuses),
+    filePathForSchemaSection(pmRoot, normalizedSchema.files.fields, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.fields),
+    filePathForSchemaSection(pmRoot, normalizedSchema.files.workflows, DEFAULT_RUNTIME_SCHEMA_FILE_PATHS.workflows)
+  ];
+}
+async function cacheSettingsReadResult(pmRoot, trackedPaths, result) {
+  const signatures = await collectSettingsReadCacheSignatures(trackedPaths);
+  setSettingsReadCacheEntry(pmRoot, {
+    tracked_paths: trackedPaths,
+    signatures,
+    value: cloneSettingsReadResult(result)
+  });
+}
+async function cacheSettingsReadResultSafe(pmRoot, trackedPaths, result) {
+  try {
+    await cacheSettingsReadResult(pmRoot, trackedPaths, result);
+  } catch {
+    clearSettingsReadCache(pmRoot);
+  }
+}
+function findSettingsReadCacheSignature(signatures, targetPath) {
+  return signatures.find((signature) => signature.path === targetPath);
+}
+function selectedSettingsReadCacheSignaturesEqual(before, after, targetPaths) {
+  for (const targetPath of targetPaths) {
+    const beforeSignature = findSettingsReadCacheSignature(before, targetPath);
+    const afterSignature = findSettingsReadCacheSignature(after, targetPath);
+    if (!beforeSignature || !afterSignature || !settingsReadCacheSignaturesEqual([beforeSignature], [afterSignature])) {
+      return false;
+    }
+  }
+  return true;
+}
+async function cacheSettingsReadResultIfStable(pmRoot, trackedPaths, result, stableSignatures, stablePaths) {
+  try {
+    const currentSignatures = await collectSettingsReadCacheSignatures(trackedPaths);
+    if (!selectedSettingsReadCacheSignaturesEqual(stableSignatures, currentSignatures, stablePaths)) {
+      clearSettingsReadCache(pmRoot);
+      return;
+    }
+    setSettingsReadCacheEntry(pmRoot, {
+      tracked_paths: trackedPaths,
+      signatures: currentSignatures,
+      value: cloneSettingsReadResult(result)
+    });
+  } catch {
+    clearSettingsReadCache(pmRoot);
+  }
+}
 function resolvePersistedFileBackedSchemaSections(settings, source) {
   const normalizedSchema = normalizeRuntimeSchemaSettings(settings.schema);
   const currentItemTypeDefinitions = normalizeItemTypeDefinitions(settings.item_types?.definitions);
@@ -5494,11 +5692,33 @@ function normalizeExtensionPolicyOverrides(overrides) {
   }
   return [...dedupedByName.values()].sort((left, right) => left.name.localeCompare(right.name));
 }
+function normalizePmMaxVersionExceededModeValue2(value) {
+  return value === "block" || value === "warn" ? value : void 0;
+}
+function normalizePmMaxVersionExceededModeSetting(value) {
+  if (typeof value === "string") {
+    return normalizePmMaxVersionExceededModeValue2(value);
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const global = normalizePmMaxVersionExceededModeValue2(value.global);
+    const project = normalizePmMaxVersionExceededModeValue2(value.project);
+    if (global === void 0 && project === void 0) {
+      return void 0;
+    }
+    return {
+      ...global !== void 0 ? { global } : {},
+      ...project !== void 0 ? { project } : {}
+    };
+  }
+  return void 0;
+}
 function normalizeExtensionPolicySettings(policy) {
   const defaults = SETTINGS_DEFAULTS.extensions.policy;
+  const pmMaxVersionExceededMode2 = normalizePmMaxVersionExceededModeSetting(policy?.pm_max_version_exceeded_mode);
   return {
     mode: normalizeExtensionPolicyMode(policy?.mode),
     trust_mode: normalizeExtensionTrustMode(policy?.trust_mode),
+    ...pmMaxVersionExceededMode2 !== void 0 ? { pm_max_version_exceeded_mode: pmMaxVersionExceededMode2 } : {},
     require_provenance: policy?.require_provenance === true,
     trusted_extensions: normalizeLowerStringList(policy?.trusted_extensions ?? defaults.trusted_extensions),
     default_sandbox_profile: normalizeExtensionSandboxProfile(policy?.default_sandbox_profile),
@@ -5787,6 +6007,7 @@ function serializeSettings(settings, options = {}) {
   ordered.extensions.policy = orderObject(ordered.extensions.policy ?? {}, [
     "mode",
     "trust_mode",
+    "pm_max_version_exceeded_mode",
     "require_provenance",
     "trusted_extensions",
     "default_sandbox_profile",
@@ -5853,28 +6074,52 @@ function serializeSettings(settings, options = {}) {
 }
 async function readSettingsWithMetadata(pmRoot) {
   const settingsPath = getSettingsPath(pmRoot);
-  const raw = await readFileIfExists(settingsPath);
-  if (raw === null) {
-    return buildFallbackSettingsReadResult();
-  }
+  let trackedPathsForFailure = [settingsPath];
   await runActiveOnReadHooks({
     path: settingsPath,
     scope: "project"
   });
+  const cachedResult = getSettingsReadCacheEntry(pmRoot);
+  if (cachedResult) {
+    const currentSignatures = await collectSettingsReadCacheSignatures(cachedResult.tracked_paths);
+    if (settingsReadCacheSignaturesEqual(currentSignatures, cachedResult.signatures)) {
+      return cloneSettingsReadResult(cachedResult.value);
+    }
+  }
+  const settingsOnlySignatures = await collectSettingsReadCacheSignatures([settingsPath]);
+  const raw = await readFileIfExists(settingsPath);
+  if (raw === null) {
+    const fallback = buildFallbackSettingsReadResult();
+    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsOnlySignatures, [settingsPath]);
+    return fallback;
+  }
+  const settingsSignaturesAfterRead = await collectSettingsReadCacheSignatures([settingsPath]);
+  if (!settingsReadCacheSignaturesEqual(settingsOnlySignatures, settingsSignaturesAfterRead)) {
+    clearSettingsReadCache(pmRoot);
+    return readSettingsWithMetadata(pmRoot);
+  }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return buildFallbackSettingsReadResult("settings_read_invalid_json");
+    const fallback = buildFallbackSettingsReadResult("settings_read_invalid_json");
+    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
+    return fallback;
   }
   const validated = validateSettings(parsed);
   if (!validated.success) {
-    return buildFallbackSettingsReadResult("settings_read_invalid_schema");
+    const fallback = buildFallbackSettingsReadResult("settings_read_invalid_schema");
+    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
+    return fallback;
   }
   try {
     const mergedSettings = mergeSettings(validated.data);
+    const trackedPaths = resolveSettingsReadTrackedPaths(pmRoot, mergedSettings.schema, settingsPath);
+    trackedPathsForFailure = trackedPaths;
+    const signaturesBeforeSchemaLoad = await collectSettingsReadCacheSignatures(trackedPaths);
     const schemaScaffold = await ensureRuntimeSchemaFileScaffold(pmRoot, mergedSettings.schema);
     const loadedSchemaSections = await loadRuntimeSchemaFromOptionalFiles(pmRoot, mergedSettings.schema);
+    const signaturesAfterSchemaLoad = await collectSettingsReadCacheSignatures(trackedPaths);
     const settings = {
       ...mergedSettings,
       item_types: {
@@ -5886,7 +6131,7 @@ async function readSettingsWithMetadata(pmRoot) {
       schema: loadedSchemaSections.schema
     };
     attachSettingsPersistSourceSnapshot(settings, buildSettingsPersistSourceSnapshot(validated.data, settings));
-    return {
+    const result = {
       settings,
       metadata: {
         has_explicit_item_format: hasExplicitItemFormat(parsed)
@@ -5897,8 +6142,24 @@ async function readSettingsWithMetadata(pmRoot) {
         ...loadedSchemaSections.warnings
       ]
     };
+    if (schemaScaffold.created_paths.length === 0) {
+      if (!settingsReadCacheSignaturesEqual(signaturesBeforeSchemaLoad, signaturesAfterSchemaLoad)) {
+        clearSettingsReadCache(pmRoot);
+      } else {
+        setSettingsReadCacheEntry(pmRoot, {
+          tracked_paths: trackedPaths,
+          signatures: signaturesAfterSchemaLoad,
+          value: cloneSettingsReadResult(result)
+        });
+      }
+    } else {
+      clearSettingsReadCache(pmRoot);
+    }
+    return result;
   } catch {
-    return buildFallbackSettingsReadResult("settings_read_merge_failed");
+    const fallback = buildFallbackSettingsReadResult("settings_read_merge_failed");
+    await cacheSettingsReadResultSafe(pmRoot, trackedPathsForFailure, fallback);
+    return fallback;
   }
 }
 async function readSettings(pmRoot) {
@@ -5909,11 +6170,15 @@ async function writeSettings(pmRoot, settings, op = SETTINGS_WRITE_OP) {
   await writeFileAtomic(settingsPath, serializeSettings(settings, {
     persist_source: getSettingsPersistSourceSnapshot(settings)
   }));
-  await runActiveOnWriteHooks({
-    path: settingsPath,
-    scope: "project",
-    op
-  });
+  try {
+    await runActiveOnWriteHooks({
+      path: settingsPath,
+      scope: "project",
+      op
+    });
+  } finally {
+    clearSettingsReadCache(pmRoot);
+  }
 }
 
 export {
@@ -6052,6 +6317,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-5JF76OJF.js.map
+//# sourceMappingURL=chunk-A6LXQFO7.js.map
 
-//# debugId=fb874b51-e242-55eb-aa06-2173035fe85d
+//# debugId=3d81dd28-0239-582e-84cb-25d9dea99250