@unbrained/pm-cli 2026.6.8 → 2026.6.10

package/dist/cli-bundle/chunks/{chunk-YJAKN2N2.js → chunk-WNMRICXH.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]="0b9873ce-4d2c-5248-a389-357401ce7cbc")}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]="c3981b80-9acf-59eb-b3e4-2434796a7689")}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,
@@ -1404,6 +1425,128 @@ import fs3 from "node:fs/promises";
 import path5 from "node:path";
 import { pathToFileURL } from "node:url";
 
+// dist/core/extensions/flag-value-types.js
+var FLAG_VALUE_KIND_BY_ALIAS = Object.freeze({
+  string: "string",
+  number: "number",
+  int: "number",
+  integer: "number",
+  float: "number",
+  boolean: "boolean",
+  bool: "boolean"
+});
+function resolveFlagValueKind(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  return FLAG_VALUE_KIND_BY_ALIAS[raw.trim().toLowerCase()] ?? null;
+}
+function flattenFlagListValue(value) {
+  const entries = [];
+  const collect = (input) => {
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        collect(item);
+      }
+      return;
+    }
+    if (typeof input === "string") {
+      for (const part of input.split(",")) {
+        const trimmed = part.trim();
+        if (trimmed.length > 0) {
+          entries.push(trimmed);
+        }
+      }
+      return;
+    }
+    if (input !== void 0 && input !== null) {
+      entries.push(input);
+    }
+  };
+  collect(value);
+  return entries;
+}
+function isFlagDefaultValueCoercible(value, kind) {
+  if (kind === "string") {
+    return true;
+  }
+  if (kind === "number") {
+    if (typeof value === "number") {
+      return Number.isFinite(value);
+    }
+    return typeof value === "string" && value.trim().length > 0 && Number.isFinite(Number(value));
+  }
+  if (typeof value === "boolean") {
+    return true;
+  }
+  return typeof value === "string" && ["true", "false", "1", "0"].includes(value.trim().toLowerCase());
+}
+
+// dist/core/shared/levenshtein.js
+function levenshteinDistanceWithinLimit(left, right, limit) {
+  if (left === right) {
+    return 0;
+  }
+  if (Math.abs(left.length - right.length) > limit) {
+    return null;
+  }
+  const width = right.length + 1;
+  const beforePrevious = new Array(width);
+  const previous = new Array(width);
+  const current = new Array(width);
+  for (let column = 0; column < width; column += 1) {
+    beforePrevious[column] = 0;
+    previous[column] = column;
+  }
+  for (let row = 1; row <= left.length; row += 1) {
+    current[0] = row;
+    let rowMin = current[0];
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      const substitution = previous[column - 1] + cost;
+      const insertion = current[column - 1] + 1;
+      const deletion = previous[column] + 1;
+      let candidate = Math.min(substitution, insertion, deletion);
+      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+        candidate = Math.min(candidate, beforePrevious[column - 2] + 1);
+      }
+      current[column] = candidate;
+      if (candidate < rowMin) {
+        rowMin = candidate;
+      }
+    }
+    if (rowMin > limit) {
+      return null;
+    }
+    for (let column = 0; column < width; column += 1) {
+      beforePrevious[column] = previous[column];
+      previous[column] = current[column];
+    }
+  }
+  const result = previous[right.length];
+  return result <= limit ? result : null;
+}
+
+// dist/core/extensions/item-field-types.js
+var KNOWN_ITEM_FIELD_TYPES = ["string", "number", "boolean", "array", "object"];
+function normalizeItemFieldType(value) {
+  const normalized = value.trim().toLowerCase();
+  return KNOWN_ITEM_FIELD_TYPES.includes(normalized) ? normalized : null;
+}
+function suggestKnownItemFieldType(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return null;
+  }
+  const limit = Math.max(1, Math.floor(normalized.length * 0.34));
+  for (const candidate of KNOWN_ITEM_FIELD_TYPES) {
+    if (levenshteinDistanceWithinLimit(normalized, candidate, limit) !== null) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
 // dist/core/extensions/extension-policy.js
 function normalizePolicyName(value) {
   if (typeof value !== "string") {
@@ -1452,6 +1595,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));
 }
@@ -1495,6 +1661,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);
@@ -1540,6 +1707,7 @@ function normalizeExtensionPolicy(settings) {
   return {
     mode,
     trustMode,
+    pmMaxVersionExceededMode: pmMaxVersionExceededMode2,
     requireProvenance,
     trustedExtensions,
     defaultSandboxProfile,
@@ -1580,6 +1748,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,
@@ -1603,6 +1772,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),
@@ -2176,14 +2346,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) {
@@ -2192,7 +2362,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)) {
@@ -2259,7 +2429,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);
   }
@@ -2309,8 +2479,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 = [];
@@ -2435,7 +2605,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 };
   }
@@ -2466,6 +2636,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}`
@@ -2535,21 +2711,28 @@ async function loadExtensions(options) {
     failed
   };
 }
+function toActivatableExtension(source) {
+  const activate = source.activate;
+  const activatable = {
+    activate: activate.bind(source)
+  };
+  if (typeof source.deactivate === "function") {
+    const deactivate = source.deactivate;
+    activatable.deactivate = deactivate.bind(source);
+  }
+  return activatable;
+}
 function resolveActivatableExtension(module) {
   const moduleRecord = asRecordLoose(module);
   if (!moduleRecord) {
     return null;
   }
   if (typeof moduleRecord.activate === "function") {
-    return {
-      activate: moduleRecord.activate
-    };
+    return toActivatableExtension(moduleRecord);
   }
   const defaultExport = asRecordLoose(moduleRecord.default);
   if (defaultExport && typeof defaultExport.activate === "function") {
-    return {
-      activate: defaultExport.activate
-    };
+    return toActivatableExtension(defaultExport);
   }
   return null;
 }
@@ -2676,6 +2859,25 @@ function assertOptionalStringField(name, value) {
     throw new TypeError(`${name} must be a non-empty string when provided`);
   }
 }
+function isFlagDefaultScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function assertOptionalFlagDefaultField(name, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      if (!isFlagDefaultScalar(item)) {
+        throw new TypeError(`${name}[${index}] must be a string, number, or boolean`);
+      }
+    }
+    return;
+  }
+  if (!isFlagDefaultScalar(value)) {
+    throw new TypeError(`${name} must be a string, number, or boolean, or an array of these when provided`);
+  }
+}
 function assertOptionalStringArrayField(name, value) {
   if (value === void 0) {
     return;
@@ -2789,6 +2991,32 @@ function validateFlagDefinitions(flags) {
     assertOptionalBooleanField(`registerFlags flags[${index}].required`, record.required);
     assertOptionalBooleanField(`registerFlags flags[${index}].enabled`, record.enabled);
     assertOptionalBooleanField(`registerFlags flags[${index}].visible`, record.visible);
+    assertOptionalBooleanField(`registerFlags flags[${index}].list`, record.list);
+    assertOptionalFlagDefaultField(`registerFlags flags[${index}].default`, record.default);
+    if (Array.isArray(record.default) && record.list !== true) {
+      throw new TypeError(`registerFlags flags[${index}].default cannot be an array unless list is true.`);
+    }
+    assertFlagValueTypeAndDefault(`registerFlags flags[${index}]`, record);
+  }
+}
+function assertFlagValueTypeAndDefault(label, record) {
+  const declaredType = (typeof record.value_type === "string" ? record.value_type : void 0) ?? (typeof record.type === "string" ? record.type : void 0);
+  if (declaredType === void 0) {
+    return;
+  }
+  const kind = resolveFlagValueKind(declaredType);
+  if (kind === null) {
+    throw new TypeError(`${label} value_type "${declaredType}" is not a known flag value type (expected one of: string, number, boolean).`);
+  }
+  if (record.default === void 0) {
+    return;
+  }
+  const defaults = record.list === true ? flattenFlagListValue(record.default) : [record.default];
+  for (const [defaultIndex, defaultValue] of defaults.entries()) {
+    if (!isFlagDefaultValueCoercible(defaultValue, kind)) {
+      const suffix = defaults.length > 1 ? `default[${defaultIndex}]` : "default";
+      throw new TypeError(`${label}.${suffix} (${JSON.stringify(defaultValue)}) is not coercible to ${kind}.`);
+    }
   }
 }
 function validateItemFieldDefinitions(fields) {
@@ -2798,7 +3026,12 @@ function validateItemFieldDefinitions(fields) {
   for (const [index, raw] of fields.entries()) {
     const record = asRegistrationRecord(`registerItemFields fields[${index}]`, raw);
     assertNonEmptyString(`registerItemFields fields[${index}].name`, record.name);
-    assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+    const fieldType = assertNonEmptyString(`registerItemFields fields[${index}].type`, record.type);
+    if (normalizeItemFieldType(fieldType) === null) {
+      const suggestion = suggestKnownItemFieldType(fieldType);
+      const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
+      throw new TypeError(`registerItemFields fields[${index}].type "${fieldType}" is not a known field type (expected one of: ${KNOWN_ITEM_FIELD_TYPES.join(", ")}).${hint}`);
+    }
     assertOptionalBooleanField(`registerItemFields fields[${index}].optional`, record.optional);
   }
 }
@@ -2896,6 +3129,15 @@ function assertExtensionCapability(extension, capability, method) {
   }
 }
 function createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
+  const selfIdentity = Object.freeze({
+    name: extension.name,
+    layer: extension.layer,
+    version: extension.version,
+    capabilities: Object.freeze((extension.capabilities ?? []).filter((capability) => KNOWN_EXTENSION_CAPABILITIES.includes(capability))),
+    pm_min_version: extension.pm_min_version,
+    pm_max_version: extension.pm_max_version,
+    source_package: extension.source_package
+  });
   const extensionRef = {
     layer: extension.layer,
     name: extension.name,
@@ -3337,6 +3579,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     });
   };
   return {
+    extension: selfIdentity,
     registerCommand,
     registerParser,
     registerPreflight,
@@ -3886,6 +4129,8 @@ var CONTEXT_SECTION_VALUES = [
   "hierarchy",
   "activity",
   "progress",
+  "recently_created",
+  "unparented",
   "blockers",
   "files",
   "workload",
@@ -4793,9 +5038,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")),
@@ -4859,6 +5110,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),
@@ -4992,6 +5245,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");
@@ -5158,6 +5476,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);
@@ -5305,11 +5691,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),
@@ -5598,6 +6006,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",
@@ -5664,28 +6073,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: {
@@ -5697,7 +6130,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)
@@ -5708,8 +6141,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) {
@@ -5720,11 +6169,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 {
@@ -5782,6 +6235,10 @@ export {
   coercePositiveInteger,
   coerceNumberInRange,
   asRecordOrNull,
+  resolveFlagValueKind,
+  flattenFlagListValue,
+  levenshteinDistanceWithinLimit,
+  normalizeItemFieldType,
   parseUnknownExtensionCapabilityWarning,
   parseLegacyExtensionCapabilityAliasWarning,
   createEmptyExtensionRegistrationRegistry,
@@ -5859,6 +6316,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-YJAKN2N2.js.map
+//# sourceMappingURL=chunk-WNMRICXH.js.map
 
-//# debugId=0b9873ce-4d2c-5248-a389-357401ce7cbc
+//# debugId=c3981b80-9acf-59eb-b3e4-2434796a7689