@unbrained/pm-cli 2026.7.4 → 2026.7.5

package/dist/cli-bundle/chunks/{chunk-SL2ANJSV.js → chunk-YD5FML7K.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]="59f1e772-921a-51db-980b-56d08f636039")}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]="b82b3892-108d-51df-a033-47913481d9b1")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -153,6 +153,16 @@ function resolvePmCliVersion(metaUrl, fallbackRelativeSegments = []) {
     return void 0;
   }
 }
+function resolveConfiguredPmPackageRoot(env = process.env, envName = "PM_CLI_PACKAGE_ROOT", metaUrl, fallbackRelativeSegments = []) {
+  const envRoot = env[envName];
+  if (typeof envRoot === "string" && envRoot.trim().length > 0) {
+    return path3.resolve(envRoot.trim());
+  }
+  if (metaUrl) {
+    return resolvePmPackageRootFromModule(metaUrl, fallbackRelativeSegments);
+  }
+  return process.cwd();
+}
 
 // dist/core/extensions/extension-types.js
 var KNOWN_EXTENSION_CAPABILITIES = [
@@ -431,7 +441,8 @@ var SETTINGS_DEFAULTS = {
   author_default: "",
   item_format: "toon",
   locks: {
-    ttl_seconds: 1800
+    ttl_seconds: 1800,
+    wait_ms: 3e3
   },
   checkpoints: {
     retention_days: 14
@@ -1592,6 +1603,23 @@ function asRecordLoose(value) {
   }
   return value;
 }
+function asPropertyRecord(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return null;
+  }
+  return value;
+}
+function resolveActivatablePropertyRecord(value) {
+  const moduleRecord = asPropertyRecord(value);
+  if (!moduleRecord) {
+    return null;
+  }
+  if (typeof moduleRecord.activate === "function") {
+    return moduleRecord;
+  }
+  const defaultExport = asPropertyRecord(moduleRecord.default);
+  return typeof defaultExport?.activate === "function" ? defaultExport : null;
+}
 
 // dist/core/shared/levenshtein.js
 function levenshteinDistanceWithinLimit(left, right, limit) {
@@ -1638,6 +1666,132 @@ function levenshteinDistanceWithinLimit(left, right, limit) {
   return result <= limit ? result : null;
 }
 
+// dist/core/extensions/extension-capability-aliases.js
+function normalizeNames(values) {
+  return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((a, b) => a.localeCompare(b));
+}
+function isKnownExtensionCapability(value) {
+  return KNOWN_EXTENSION_CAPABILITIES.includes(value);
+}
+function normalizeKnownExtensionCapability(value) {
+  const normalized = value.trim().toLowerCase();
+  return isKnownExtensionCapability(normalized) ? normalized : null;
+}
+function collectUnknownExtensionCapabilities(capabilities) {
+  return capabilities.filter((capability) => !isKnownExtensionCapability(capability));
+}
+function resolveLegacyExtensionCapabilityAlias(capability) {
+  const normalized = capability.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return null;
+  }
+  return EXTENSION_CAPABILITY_LEGACY_ALIASES[normalized] ?? null;
+}
+function normalizeManifestCapabilities(rawCapabilities) {
+  const normalizedCapabilities = normalizeNames([...rawCapabilities].map((value) => value.toLowerCase()));
+  const remappedCapabilities = [];
+  const legacyAliases = [];
+  for (const capability of normalizedCapabilities) {
+    const legacyAliasTarget = resolveLegacyExtensionCapabilityAlias(capability);
+    if (legacyAliasTarget) {
+      remappedCapabilities.push(legacyAliasTarget);
+      legacyAliases.push({
+        alias: capability,
+        target: legacyAliasTarget
+      });
+      continue;
+    }
+    remappedCapabilities.push(capability);
+  }
+  const dedupedLegacyAliases = [...new Map(legacyAliases.map((entry) => [`${entry.alias}>${entry.target}`, entry])).values()].sort((left, right) => left.alias.localeCompare(right.alias));
+  return {
+    capabilities: normalizeNames(remappedCapabilities),
+    legacy_aliases: dedupedLegacyAliases
+  };
+}
+function suggestKnownExtensionCapability(capability) {
+  const normalized = capability.trim().toLowerCase();
+  if (normalized.length === 0) {
+    return null;
+  }
+  const legacyAlias = resolveLegacyExtensionCapabilityAlias(normalized);
+  if (legacyAlias) {
+    return legacyAlias;
+  }
+  const maxDistance = Math.max(1, Math.floor(normalized.length * 0.34));
+  let bestMatch = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of KNOWN_EXTENSION_CAPABILITIES) {
+    const distance = levenshteinDistanceWithinLimit(normalized, candidate, maxDistance);
+    if (distance !== null && distance < bestDistance) {
+      bestDistance = distance;
+      bestMatch = candidate;
+    }
+  }
+  return bestMatch;
+}
+function formatUnknownExtensionCapabilityWarning(layer, name, capability) {
+  const allowed = KNOWN_EXTENSION_CAPABILITIES.join(",");
+  const suggested = suggestKnownExtensionCapability(capability) ?? "none";
+  return `extension_capability_unknown:${layer}:${name}:${capability}:allowed=${allowed}:suggested=${suggested}`;
+}
+function formatLegacyExtensionCapabilityAliasWarning(layer, name, aliases) {
+  const aliasesToken = aliases.map((entry) => `${entry.alias}>${entry.target}`).join(",");
+  return `extension_capability_legacy_alias:${layer}:${name}:aliases=${aliasesToken}`;
+}
+function parseUnknownExtensionCapabilityWarning(warning) {
+  const match = /^extension_capability_unknown:(global|project):([^:]+):([^:]+):allowed=([^:]+):suggested=([^:]+)$/.exec(warning.trim());
+  if (!match) {
+    return null;
+  }
+  const [, layerRaw, name, capability, allowedRaw, suggestedRaw] = match;
+  const layer = layerRaw;
+  const allowed_capabilities = allowedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+  const legacyAlias = resolveLegacyExtensionCapabilityAlias(capability);
+  const suggestedFromWarning = suggestedRaw === "none" ? void 0 : suggestedRaw;
+  const suggested_capability = suggestedFromWarning ?? legacyAlias ?? void 0;
+  const suggestion_source = suggested_capability ? legacyAlias === suggested_capability ? "legacy_alias" : "nearest_match" : void 0;
+  return {
+    layer,
+    name,
+    capability,
+    allowed_capabilities,
+    capability_contract_version: EXTENSION_CAPABILITY_CONTRACT_VERSION,
+    suggested_capability,
+    suggestion_source,
+    legacy_alias_target: legacyAlias ?? void 0
+  };
+}
+function parseLegacyExtensionCapabilityAliasWarning(warning) {
+  const match = /^extension_capability_legacy_alias:(global|project):([^:]+):aliases=(.+)$/.exec(warning.trim());
+  if (!match) {
+    return [];
+  }
+  const [, layerRaw, name, aliasesRaw] = match;
+  const layer = layerRaw;
+  const allowedCapabilities = [...KNOWN_EXTENSION_CAPABILITIES];
+  const parsed = [];
+  for (const token of aliasesRaw.split(",")) {
+    const [rawAlias, rawTarget] = token.split(">");
+    const alias = rawAlias?.trim();
+    const target = rawTarget?.trim().toLowerCase();
+    if (!alias || !target || !isKnownExtensionCapability(target)) {
+      continue;
+    }
+    parsed.push({
+      layer,
+      name,
+      capability: alias,
+      allowed_capabilities: allowedCapabilities,
+      capability_contract_version: EXTENSION_CAPABILITY_CONTRACT_VERSION,
+      suggested_capability: target,
+      suggestion_source: "legacy_alias",
+      legacy_alias_target: target
+    });
+  }
+  return parsed;
+}
+
 // dist/core/extensions/extension-registries.js
 function createEmptyExtensionHookRegistry() {
   return {
@@ -2269,205 +2423,79 @@ function evaluatePmMaxVersionBound(required, currentVersion, exceededMode) {
   return { kind: "pm_max_version", status: "ok", allowed: true, required: declared, current: currentVersion };
 }
 
-// dist/core/extensions/extension-capability-aliases.js
-function normalizeNames(values) {
-  return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((a, b) => a.localeCompare(b));
+// dist/core/extensions/extension-policy.js
+function normalizePolicyName(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim().toLowerCase();
 }
-function isKnownExtensionCapability(value) {
-  return KNOWN_EXTENSION_CAPABILITIES.includes(value);
+function normalizePolicyStringSet(values) {
+  return new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0));
 }
-function normalizeKnownExtensionCapability(value) {
+function normalizePolicySurfaceToken(value) {
   const normalized = value.trim().toLowerCase();
-  return isKnownExtensionCapability(normalized) ? normalized : null;
+  if (normalized.length === 0) {
+    return "";
+  }
+  const segments = normalized.split(/[.:/]/).map((segment) => segment.replace(/[\s_-]+/g, "")).filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return "";
+  }
+  if (segments.length === 1) {
+    return segments[0];
+  }
+  return `${segments[0]}.${segments.slice(1).join("")}`;
 }
-function collectUnknownExtensionCapabilities(capabilities) {
-  return capabilities.filter((capability) => !isKnownExtensionCapability(capability));
+function normalizePolicySurfaceSet(values) {
+  return new Set((values ?? []).map((value) => normalizePolicySurfaceToken(value)).filter((value) => value.length > 0));
 }
-function resolveLegacyExtensionCapabilityAlias(capability) {
-  const normalized = capability.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return null;
+function normalizePolicyMode(value) {
+  const normalized = normalizePolicyName(value);
+  if (KNOWN_EXTENSION_POLICY_MODES.includes(normalized)) {
+    return normalized;
   }
-  return EXTENSION_CAPABILITY_LEGACY_ALIASES[normalized] ?? null;
+  return "off";
 }
-function normalizeManifestCapabilities(rawCapabilities) {
-  const normalizedCapabilities = normalizeNames([...rawCapabilities].map((value) => value.toLowerCase()));
-  const remappedCapabilities = [];
-  const legacyAliases = [];
-  for (const capability of normalizedCapabilities) {
-    const legacyAliasTarget = resolveLegacyExtensionCapabilityAlias(capability);
-    if (legacyAliasTarget) {
-      remappedCapabilities.push(legacyAliasTarget);
-      legacyAliases.push({
-        alias: capability,
-        target: legacyAliasTarget
-      });
-      continue;
-    }
-    remappedCapabilities.push(capability);
+function normalizePolicyTrustMode(value) {
+  const normalized = normalizePolicyName(value);
+  if (KNOWN_EXTENSION_TRUST_MODES.includes(normalized)) {
+    return normalized;
   }
-  const dedupedLegacyAliases = [...new Map(legacyAliases.map((entry) => [`${entry.alias}>${entry.target}`, entry])).values()].sort((left, right) => left.alias.localeCompare(right.alias));
-  return {
-    capabilities: normalizeNames(remappedCapabilities),
-    legacy_aliases: dedupedLegacyAliases
-  };
+  return "off";
 }
-function suggestKnownExtensionCapability(capability) {
-  const normalized = capability.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return null;
+function normalizePolicySandboxProfile(value) {
+  const normalized = normalizePolicyName(value);
+  if (KNOWN_EXTENSION_SANDBOX_PROFILES.includes(normalized)) {
+    return normalized;
   }
-  const legacyAlias = resolveLegacyExtensionCapabilityAlias(normalized);
-  if (legacyAlias) {
-    return legacyAlias;
+  return "none";
+}
+function normalizePmMaxVersionExceededModeValue(value) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  const maxDistance = Math.max(1, Math.floor(normalized.length * 0.34));
-  let bestMatch = null;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (const candidate of KNOWN_EXTENSION_CAPABILITIES) {
-    const distance = levenshteinDistanceWithinLimit(normalized, candidate, maxDistance);
-    if (distance !== null && distance < bestDistance) {
-      bestDistance = distance;
-      bestMatch = candidate;
-    }
+  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 };
   }
-  return bestMatch;
+  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 formatUnknownExtensionCapabilityWarning(layer, name, capability) {
-  const allowed = KNOWN_EXTENSION_CAPABILITIES.join(",");
-  const suggested = suggestKnownExtensionCapability(capability) ?? "none";
-  return `extension_capability_unknown:${layer}:${name}:${capability}:allowed=${allowed}:suggested=${suggested}`;
+function serializePmMaxVersionExceededMode(mode) {
+  return mode.global === mode.project ? mode.global : { global: mode.global, project: mode.project };
 }
-function formatLegacyExtensionCapabilityAliasWarning(layer, name, aliases) {
-  const aliasesToken = aliases.map((entry) => `${entry.alias}>${entry.target}`).join(",");
-  return `extension_capability_legacy_alias:${layer}:${name}:aliases=${aliasesToken}`;
-}
-function parseUnknownExtensionCapabilityWarning(warning) {
-  const match = /^extension_capability_unknown:(global|project):([^:]+):([^:]+):allowed=([^:]+):suggested=([^:]+)$/.exec(warning.trim());
-  if (!match) {
-    return null;
-  }
-  const [, layerRaw, name, capability, allowedRaw, suggestedRaw] = match;
-  const layer = layerRaw;
-  const allowed_capabilities = allowedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
-  const legacyAlias = resolveLegacyExtensionCapabilityAlias(capability);
-  const suggestedFromWarning = suggestedRaw === "none" ? void 0 : suggestedRaw;
-  const suggested_capability = suggestedFromWarning ?? legacyAlias ?? void 0;
-  const suggestion_source = suggested_capability ? legacyAlias === suggested_capability ? "legacy_alias" : "nearest_match" : void 0;
-  return {
-    layer,
-    name,
-    capability,
-    allowed_capabilities,
-    capability_contract_version: EXTENSION_CAPABILITY_CONTRACT_VERSION,
-    suggested_capability,
-    suggestion_source,
-    legacy_alias_target: legacyAlias ?? void 0
-  };
-}
-function parseLegacyExtensionCapabilityAliasWarning(warning) {
-  const match = /^extension_capability_legacy_alias:(global|project):([^:]+):aliases=(.+)$/.exec(warning.trim());
-  if (!match) {
-    return [];
-  }
-  const [, layerRaw, name, aliasesRaw] = match;
-  const layer = layerRaw;
-  const allowedCapabilities = [...KNOWN_EXTENSION_CAPABILITIES];
-  const parsed = [];
-  for (const token of aliasesRaw.split(",")) {
-    const [rawAlias, rawTarget] = token.split(">");
-    const alias = rawAlias?.trim();
-    const target = rawTarget?.trim().toLowerCase();
-    if (!alias || !target || !isKnownExtensionCapability(target)) {
-      continue;
-    }
-    parsed.push({
-      layer,
-      name,
-      capability: alias,
-      allowed_capabilities: allowedCapabilities,
-      capability_contract_version: EXTENSION_CAPABILITY_CONTRACT_VERSION,
-      suggested_capability: target,
-      suggestion_source: "legacy_alias",
-      legacy_alias_target: target
-    });
-  }
-  return parsed;
-}
-
-// dist/core/extensions/extension-policy.js
-function normalizePolicyName(value) {
-  if (typeof value !== "string") {
-    return "";
-  }
-  return value.trim().toLowerCase();
-}
-function normalizePolicyStringSet(values) {
-  return new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0));
-}
-function normalizePolicySurfaceToken(value) {
-  const normalized = value.trim().toLowerCase();
-  if (normalized.length === 0) {
-    return "";
-  }
-  const segments = normalized.split(/[.:/]/).map((segment) => segment.replace(/[\s_-]+/g, "")).filter((segment) => segment.length > 0);
-  if (segments.length === 0) {
-    return "";
-  }
-  if (segments.length === 1) {
-    return segments[0];
-  }
-  return `${segments[0]}.${segments.slice(1).join("")}`;
-}
-function normalizePolicySurfaceSet(values) {
-  return new Set((values ?? []).map((value) => normalizePolicySurfaceToken(value)).filter((value) => value.length > 0));
-}
-function normalizePolicyMode(value) {
-  const normalized = normalizePolicyName(value);
-  if (KNOWN_EXTENSION_POLICY_MODES.includes(normalized)) {
-    return normalized;
-  }
-  return "off";
-}
-function normalizePolicyTrustMode(value) {
-  const normalized = normalizePolicyName(value);
-  if (KNOWN_EXTENSION_TRUST_MODES.includes(normalized)) {
-    return normalized;
-  }
-  return "off";
-}
-function normalizePolicySandboxProfile(value) {
-  const normalized = normalizePolicyName(value);
-  if (KNOWN_EXTENSION_SANDBOX_PROFILES.includes(normalized)) {
-    return normalized;
-  }
-  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));
+function toSortedList(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
 function buildExtensionPolicyOverride(rawOverride) {
   const name = normalizePolicyName(rawOverride.name);
@@ -3230,14 +3258,14 @@ function buildEffectiveExtensions(globalCandidates, projectCandidates) {
   }
   return effective;
 }
-async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled, pmMaxVersionExceededMode2) {
+async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled, pmMaxVersionExceededMode) {
   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, pmMaxVersionExceededMode2);
+    const scanned = await scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages, pmMaxVersionExceededMode);
     diagnostics.push(scanned.diagnostic);
     warnings.push(...scanned.warnings);
     if (scanned.candidate) {
@@ -3285,13 +3313,13 @@ function collectScannedExtensionWarnings(layer, manifest, entryWithinDirectory,
   }
   return extensionWarnings;
 }
-async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages, pmMaxVersionExceededMode2) {
+async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages, pmMaxVersionExceededMode) {
   const extensionDir = path5.join(extensionsRoot, directory);
   const manifestPath = path5.join(extensionDir, "manifest.json");
   if (!await pathExists(manifestPath)) {
     return buildUnavailableExtensionScan(layer, directory, manifestPath, `extension_manifest_missing:${layer}:${directory}`);
   }
-  let manifest = null;
+  let manifest;
   try {
     const parsed = JSON.parse(await fs3.readFile(manifestPath, "utf8"));
     manifest = parseManifest(parsed);
@@ -3307,7 +3335,7 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
   const entryWithinDirectory = entryWithinDirectoryByPath && entryExists ? await isCanonicalPathWithinDirectory(extensionDir, entryPath) : entryWithinDirectoryByPath;
   const enabledForLoad = shouldEnable(manifest.name, enabled, disabled);
   const pmVersionCompatibility = await evaluatePmMinVersionCompatibility(layer, manifest);
-  const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest, pmMaxVersionExceededMode2);
+  const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest, pmMaxVersionExceededMode);
   const extensionWarnings = collectScannedExtensionWarnings(layer, manifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility);
   const extensionReady = entryWithinDirectory && entryExists && pmVersionCompatibility.allowed && pmMaxVersionCompatibility.allowed;
   const sourcePackage = managedSourcePackages.get(`directory:${directory}`) ?? managedSourcePackages.get(`name:${manifest.name}`);
@@ -3502,7 +3530,8 @@ async function loadExtensions(options) {
       failed
     };
   }
-  for (const extension of discovery.effective) {
+  const extensionsToLoad = typeof options.extensionFilter === "function" ? discovery.effective.filter(options.extensionFilter) : discovery.effective;
+  for (const extension of extensionsToLoad) {
     try {
       const importHref = await resolveExtensionImportHref(extension, options);
       const module = await import(importHref);
@@ -3527,6 +3556,8 @@ async function loadExtensions(options) {
     failed
   };
 }
+var DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS = 5e3;
+var MAX_EXTENSION_DEACTIVATE_TIMEOUT_MS = 2147483647;
 function toActivatableExtension(source) {
   const activate = source.activate;
   const activatable = {
@@ -3539,18 +3570,78 @@ function toActivatableExtension(source) {
   return activatable;
 }
 function resolveActivatableExtension(module) {
-  const moduleRecord = asRecordLoose(module);
-  if (!moduleRecord) {
-    return null;
+  const activatableRecord = resolveActivatablePropertyRecord(module);
+  return activatableRecord ? toActivatableExtension(activatableRecord) : null;
+}
+async function deactivateExtensions(loadResult, activationResult, options = {}) {
+  const timeoutMs = normalizeExtensionDeactivateTimeout(options?.deactivate_timeout_ms);
+  const failedActivationKeys = new Set((activationResult?.failed ?? []).map((entry) => `${entry.layer}:${entry.name}`));
+  const targets = [];
+  for (const extension of loadResult.loaded) {
+    if (failedActivationKeys.has(`${extension.layer}:${extension.name}`)) {
+      continue;
+    }
+    const activatable = resolveActivatableExtension(extension.module);
+    if (!activatable || typeof activatable.deactivate !== "function") {
+      continue;
+    }
+    targets.push({ extension, deactivate: activatable.deactivate });
   }
-  if (typeof moduleRecord.activate === "function") {
-    return toActivatableExtension(moduleRecord);
+  const outcomes = await Promise.all(targets.map(async ({ extension, deactivate }) => {
+    try {
+      await runExtensionDeactivateWithTimeout(deactivate, timeoutMs);
+      return { ok: true };
+    } catch (error) {
+      return { ok: false, layer: extension.layer, name: extension.name, error: formatUnknownError(error) };
+    }
+  }));
+  const warnings = [];
+  const failed = [];
+  let deactivated = 0;
+  for (const outcome of outcomes) {
+    if (outcome.ok) {
+      deactivated += 1;
+      continue;
+    }
+    warnings.push(`extension_deactivate_failed:${outcome.layer}:${outcome.name}`);
+    failed.push({ layer: outcome.layer, name: outcome.name, error: outcome.error });
   }
-  const defaultExport = asRecordLoose(moduleRecord.default);
-  if (defaultExport && typeof defaultExport.activate === "function") {
-    return toActivatableExtension(defaultExport);
+  return { deactivated, warnings, failed };
+}
+function normalizeExtensionDeactivateTimeout(rawTimeout) {
+  if (typeof rawTimeout !== "number" || rawTimeout < 0) {
+    return DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS;
+  }
+  if (rawTimeout === 0 || rawTimeout === Infinity) {
+    return 0;
+  }
+  if (!Number.isFinite(rawTimeout)) {
+    return DEFAULT_EXTENSION_DEACTIVATE_TIMEOUT_MS;
+  }
+  return Math.min(MAX_EXTENSION_DEACTIVATE_TIMEOUT_MS, Math.max(1, Math.floor(rawTimeout)));
+}
+async function runExtensionDeactivateWithTimeout(deactivate, timeoutMs) {
+  if (timeoutMs === 0) {
+    await deactivate();
+    return;
+  }
+  let timeoutHandle;
+  try {
+    const deactivatePromise = Promise.resolve().then(() => deactivate());
+    deactivatePromise.catch(() => {
+    });
+    await Promise.race([
+      deactivatePromise,
+      new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new Error(`extension deactivate timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timeoutHandle.unref?.();
+      })
+    ]);
+  } finally {
+    clearTimeout(timeoutHandle);
   }
-  return null;
 }
 function isOutputRendererFormat(value) {
   return value === "toon" || value === "json";
@@ -4705,6 +4796,17 @@ async function activateExtensions(loadResult) {
 }
 
 // dist/core/extensions/capability-usage.js
+var EXTENSION_CAPABILITY_REGISTRATION_SURFACES = {
+  commands: ["registerCommand", "command override", "command handler"],
+  renderers: ["registerRenderer"],
+  hooks: ["hooks.beforeCommand", "hooks.afterCommand", "hooks.onWrite", "hooks.onRead", "hooks.onIndex"],
+  schema: ["registerFlags", "registerItemFields", "registerItemTypes", "registerMigration", "registerProfile"],
+  importers: ["registerImporter", "registerExporter"],
+  search: ["registerSearchProvider", "registerVectorStoreAdapter"],
+  parser: ["registerParser"],
+  preflight: ["registerPreflight"],
+  services: ["registerService"]
+};
 var USAGE_KEY_SEPARATOR = ":";
 function usageKey(layer, name) {
   return `${layer}${USAGE_KEY_SEPARATOR}${normalizeExtensionName(name)}`;
@@ -4767,10 +4869,16 @@ function attributeCapabilityUsage(activation) {
 }
 function collectUsedExtensionCapabilities(activation, options = {}) {
   const usage = attributeCapabilityUsage(activation);
-  const filter = options.extensionName !== void 0 ? normalizeExtensionName(options.extensionName) : null;
+  const filters = /* @__PURE__ */ new Set();
+  if (options.extensionName !== void 0) {
+    filters.add(normalizeExtensionName(options.extensionName));
+  }
+  for (const name of options.extensionNames ?? []) {
+    filters.add(normalizeExtensionName(name));
+  }
   const used = /* @__PURE__ */ new Set();
   for (const [key, capabilities] of usage) {
-    if (filter !== null && usageKeyName(key) !== filter) {
+    if (filters.size > 0 && !filters.has(usageKeyName(key))) {
       continue;
     }
     for (const capability of capabilities) {
@@ -4795,333 +4903,92 @@ function reconcileExtensionCapabilityUsage(loaded, activation) {
   return reconciliations;
 }
 
-// dist/core/extensions/index.js
-var activeExtensionHooks = null;
-var activeExtensionCommands = null;
-var activeExtensionParsers = null;
-var activeExtensionPreflight = null;
-var activeExtensionServices = null;
-var activeExtensionRenderers = null;
-var activeExtensionRegistrations = null;
-var activeCommandContext = null;
-var activeCommandResult = void 0;
-var activeAfterCommandAffectedItems = [];
-var AFTER_COMMAND_SNAPSHOT_OMITTED_FIELDS = /* @__PURE__ */ new Set([
-  "body",
-  "comments",
-  "dependencies",
-  "docs",
-  "events",
-  "files",
-  "learnings",
-  "notes",
-  "reminders",
-  "test_runs",
-  "tests"
-]);
-function setActiveExtensionHooks(hooks) {
-  activeExtensionHooks = hooks;
-}
-function setActiveExtensionCommands(commands) {
-  activeExtensionCommands = commands;
-}
-function setActiveExtensionParsers(parsers) {
-  activeExtensionParsers = parsers;
+// dist/core/schema/runtime-schema.js
+import path6 from "node:path";
+var DEFAULT_RUNTIME_SCHEMA_FILE_PATHS = Object.freeze({
+  types: "schema/types.json",
+  statuses: "schema/statuses.json",
+  fields: "schema/fields.json",
+  workflows: "schema/workflows.json"
+});
+var DEFAULT_RUNTIME_WORKFLOW = DEFAULT_WORKFLOW_DEFINITION;
+var DEFAULT_RUNTIME_STATUS_DEFINITIONS = DEFAULT_STATUS_DEFINITIONS;
+var DEFAULT_RUNTIME_FIELD_COMMANDS = ["create", "update"];
+var RUNTIME_STATUS_ROLE_SET = new Set(RUNTIME_STATUS_ROLE_VALUES);
+var RUNTIME_FIELD_TYPE_SET = new Set(RUNTIME_FIELD_TYPE_VALUES);
+var RUNTIME_FIELD_COMMAND_SET = new Set(RUNTIME_FIELD_COMMAND_VALUES);
+var RUNTIME_UNKNOWN_FIELD_POLICY_SET = new Set(RUNTIME_UNKNOWN_FIELD_POLICY_VALUES);
+function normalizeStringList(values) {
+  const candidates = Array.isArray(values) ? values : [];
+  return [...new Set(candidates.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
 }
-function setActiveExtensionPreflight(preflight) {
-  activeExtensionPreflight = preflight;
+function normalizeStatusToken(value) {
+  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
 }
-function setActiveExtensionServices(services) {
-  activeExtensionServices = services;
+function normalizeStatusId(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  const normalized = normalizeStatusToken(value);
+  return normalized.length > 0 ? normalized : void 0;
 }
-function setActiveExtensionRenderers(renderers) {
-  activeExtensionRenderers = renderers;
+function stripFlagPrefix(value) {
+  return value.startsWith("--") ? value.slice(2) : value;
 }
-function setActiveExtensionRegistrations(registrations) {
-  activeExtensionRegistrations = registrations;
+function normalizeCliToken(value) {
+  return typeof value === "string" ? stripFlagPrefix(value.trim().toLowerCase().replaceAll(/[\s_]+/g, "-")) : "";
 }
-function getActiveExtensionRegistrations() {
-  return activeExtensionRegistrations;
+function keyToDefaultCliFlag(value) {
+  return value.replaceAll("_", "-");
 }
-function setActiveCommandContext(context) {
-  activeCommandContext = context;
+function toCamelCase(input) {
+  const segments = input.replaceAll(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter((segment) => segment.length > 0).map((segment) => segment.toLowerCase());
+  if (segments.length === 0) {
+    return input;
+  }
+  const [first, ...rest] = segments;
+  return `${first}${rest.map((segment) => `${segment.slice(0, 1).toUpperCase()}${segment.slice(1)}`).join("")}`;
 }
-function setActiveCommandResult(result) {
-  activeCommandResult = result;
+function normalizeRuntimeStatusDefinition(definition, fallbackOrder) {
+  const id = normalizeStatusId(definition.id);
+  if (!id) {
+    return null;
+  }
+  const aliases = normalizeStringList(definition.aliases).map((value) => normalizeStatusToken(value)).filter((value) => value !== id);
+  const roles = normalizeStringList(definition.roles).filter((value) => RUNTIME_STATUS_ROLE_SET.has(value));
+  const description = definition.description?.trim();
+  const order = typeof definition.order === "number" && Number.isFinite(definition.order) ? definition.order : fallbackOrder;
+  return {
+    id,
+    aliases,
+    roles,
+    description: description && description.length > 0 ? description : void 0,
+    order
+  };
 }
-function getActiveCommandResult() {
-  return activeCommandResult;
+function normalizeRuntimeWorkflow(workflow) {
+  return {
+    draft_status: normalizeStatusId(workflow?.draft_status),
+    open_status: normalizeStatusId(workflow?.open_status),
+    in_progress_status: normalizeStatusId(workflow?.in_progress_status),
+    blocked_status: normalizeStatusId(workflow?.blocked_status),
+    close_status: normalizeStatusId(workflow?.close_status),
+    canceled_status: normalizeStatusId(workflow?.canceled_status)
+  };
 }
-function recordAfterCommandAffectedItem(item) {
-  if (!item || (activeExtensionHooks?.afterCommand?.length ?? 0) === 0) {
+function appendTypeWorkflowPair(record, pair) {
+  if (!Array.isArray(pair) || pair.length !== 2) {
     return;
   }
-  activeAfterCommandAffectedItems.push(item);
-}
-function projectAfterCommandItemSnapshot(metadata, changedFields) {
-  if (!metadata || !metadata.id) {
-    return {};
-  }
-  const snapshot = {
-    id: metadata.id,
-    type: metadata.type,
-    status: metadata.status
-  };
-  if (!Array.isArray(changedFields)) {
-    return snapshot;
+  const from = normalizeStatusToken(pair[0]);
+  const to = normalizeStatusToken(pair[1]);
+  if (from.length === 0 || to.length === 0) {
+    return;
   }
-  const source = metadata;
-  for (const field of changedFields) {
-    if (typeof field !== "string") {
-      continue;
-    }
-    const actualField = field.startsWith("unset:") ? field.slice("unset:".length) : field;
-    if (actualField === "id" || actualField === "type" || actualField === "status" || AFTER_COMMAND_SNAPSHOT_OMITTED_FIELDS.has(actualField)) {
-      continue;
-    }
-    if (Object.hasOwn(source, actualField) && source[actualField] !== void 0) {
-      snapshot[actualField] = source[actualField];
-    }
+  if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
+    return;
   }
-  return snapshot;
-}
-function consumeAfterCommandAffectedItems() {
-  if (activeAfterCommandAffectedItems.length === 0) {
-    return void 0;
-  }
-  const affected = activeAfterCommandAffectedItems;
-  activeAfterCommandAffectedItems = [];
-  return affected;
-}
-function clearActiveExtensionHooks() {
-  activeExtensionHooks = null;
-  activeExtensionCommands = null;
-  activeExtensionParsers = null;
-  activeExtensionPreflight = null;
-  activeExtensionServices = null;
-  activeExtensionRenderers = null;
-  activeExtensionRegistrations = null;
-  activeCommandContext = null;
-  activeCommandResult = void 0;
-  activeAfterCommandAffectedItems = [];
-}
-async function runActiveOnWriteHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
-  }
-  return runOnWriteHooks(activeExtensionHooks, context);
-}
-async function runActiveOnReadHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
-  }
-  return runOnReadHooks(activeExtensionHooks, context);
-}
-function hasActiveOnReadHooks() {
-  return (activeExtensionHooks?.onRead?.length ?? 0) > 0;
-}
-async function runActiveOnIndexHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
-  }
-  return runOnIndexHooks(activeExtensionHooks, context);
-}
-function runActiveCommandOverride(result) {
-  if (!activeExtensionCommands || !activeCommandContext) {
-    return {
-      overridden: false,
-      result,
-      warnings: []
-    };
-  }
-  return runCommandOverride(activeExtensionCommands, {
-    command: activeCommandContext.command,
-    args: [...activeCommandContext.args],
-    options: activeCommandContext.options ? { ...activeCommandContext.options } : {},
-    global: activeCommandContext.global ? { ...activeCommandContext.global } : void 0,
-    pm_root: activeCommandContext.pm_root,
-    result
-  });
-}
-async function runActiveCommandHandler(context) {
-  if (!activeExtensionCommands) {
-    return {
-      handled: false,
-      result: null,
-      warnings: []
-    };
-  }
-  return runCommandHandler(activeExtensionCommands, context);
-}
-async function runActiveParserOverride(context) {
-  if (!activeExtensionParsers) {
-    return {
-      overridden: false,
-      context: {
-        command: context.command,
-        args: [...context.args],
-        options: { ...context.options },
-        global: { ...context.global },
-        pm_root: context.pm_root
-      },
-      warnings: []
-    };
-  }
-  return runParserOverride(activeExtensionParsers, context);
-}
-async function runActivePreflightOverride(context) {
-  if (!activeExtensionPreflight) {
-    return {
-      overridden: false,
-      context: {
-        command: context.command,
-        args: [...context.args],
-        options: { ...context.options },
-        global: { ...context.global },
-        pm_root: context.pm_root
-      },
-      decision: { ...context.decision },
-      warnings: []
-    };
-  }
-  return runPreflightOverride(activeExtensionPreflight, context);
-}
-function runActiveRendererOverride(format, result) {
-  if (!activeExtensionRenderers) {
-    return {
-      overridden: false,
-      rendered: null,
-      warnings: []
-    };
-  }
-  return runRendererOverride(activeExtensionRenderers, {
-    format,
-    command: activeCommandContext?.command,
-    args: activeCommandContext ? [...activeCommandContext.args] : [],
-    options: activeCommandContext?.options ? { ...activeCommandContext.options } : {},
-    global: activeCommandContext?.global ? { ...activeCommandContext.global } : void 0,
-    pm_root: activeCommandContext?.pm_root,
-    result
-  });
-}
-function buildServiceContext(service, payload) {
-  return {
-    service,
-    command: activeCommandContext?.command,
-    args: activeCommandContext ? [...activeCommandContext.args] : [],
-    options: activeCommandContext?.options ? { ...activeCommandContext.options } : {},
-    global: activeCommandContext?.global ? { ...activeCommandContext.global } : void 0,
-    pm_root: activeCommandContext?.pm_root,
-    payload
-  };
-}
-async function runActiveServiceOverride(service, payload) {
-  if (!activeExtensionServices) {
-    return {
-      handled: false,
-      result: payload,
-      warnings: []
-    };
-  }
-  return runServiceOverride(activeExtensionServices, buildServiceContext(service, payload));
-}
-function runActiveServiceOverrideSync(service, payload) {
-  if (!activeExtensionServices) {
-    return {
-      handled: false,
-      result: payload,
-      warnings: []
-    };
-  }
-  return runServiceOverrideSync(activeExtensionServices, buildServiceContext(service, payload));
-}
-
-// dist/core/schema/runtime-schema.js
-import path6 from "node:path";
-var DEFAULT_RUNTIME_SCHEMA_FILE_PATHS = Object.freeze({
-  types: "schema/types.json",
-  statuses: "schema/statuses.json",
-  fields: "schema/fields.json",
-  workflows: "schema/workflows.json"
-});
-var DEFAULT_RUNTIME_WORKFLOW = DEFAULT_WORKFLOW_DEFINITION;
-var DEFAULT_RUNTIME_STATUS_DEFINITIONS = DEFAULT_STATUS_DEFINITIONS;
-var DEFAULT_RUNTIME_FIELD_COMMANDS = ["create", "update"];
-var RUNTIME_STATUS_ROLE_SET = new Set(RUNTIME_STATUS_ROLE_VALUES);
-var RUNTIME_FIELD_TYPE_SET = new Set(RUNTIME_FIELD_TYPE_VALUES);
-var RUNTIME_FIELD_COMMAND_SET = new Set(RUNTIME_FIELD_COMMAND_VALUES);
-var RUNTIME_UNKNOWN_FIELD_POLICY_SET = new Set(RUNTIME_UNKNOWN_FIELD_POLICY_VALUES);
-function normalizeStringList(values) {
-  const candidates = Array.isArray(values) ? values : [];
-  return [...new Set(candidates.map((value) => typeof value === "string" ? value.trim() : "").filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeStatusToken(value) {
-  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
-}
-function normalizeStatusId(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return void 0;
-  }
-  const normalized = normalizeStatusToken(value);
-  return normalized.length > 0 ? normalized : void 0;
-}
-function stripFlagPrefix(value) {
-  return value.startsWith("--") ? value.slice(2) : value;
-}
-function normalizeCliToken(value) {
-  return typeof value === "string" ? stripFlagPrefix(value.trim().toLowerCase().replaceAll(/[\s_]+/g, "-")) : "";
-}
-function keyToDefaultCliFlag(value) {
-  return value.replaceAll("_", "-");
-}
-function toCamelCase(input) {
-  const segments = input.replaceAll(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter((segment) => segment.length > 0).map((segment) => segment.toLowerCase());
-  if (segments.length === 0) {
-    return input;
-  }
-  const [first, ...rest] = segments;
-  return `${first}${rest.map((segment) => `${segment.slice(0, 1).toUpperCase()}${segment.slice(1)}`).join("")}`;
-}
-function normalizeRuntimeStatusDefinition(definition, fallbackOrder) {
-  const id = normalizeStatusId(definition.id);
-  if (!id) {
-    return null;
-  }
-  const aliases = normalizeStringList(definition.aliases).map((value) => normalizeStatusToken(value)).filter((value) => value !== id);
-  const roles = normalizeStringList(definition.roles).filter((value) => RUNTIME_STATUS_ROLE_SET.has(value));
-  const description = definition.description?.trim();
-  const order = typeof definition.order === "number" && Number.isFinite(definition.order) ? definition.order : fallbackOrder;
-  return {
-    id,
-    aliases,
-    roles,
-    description: description && description.length > 0 ? description : void 0,
-    order
-  };
-}
-function normalizeRuntimeWorkflow(workflow) {
-  return {
-    draft_status: normalizeStatusId(workflow?.draft_status),
-    open_status: normalizeStatusId(workflow?.open_status),
-    in_progress_status: normalizeStatusId(workflow?.in_progress_status),
-    blocked_status: normalizeStatusId(workflow?.blocked_status),
-    close_status: normalizeStatusId(workflow?.close_status),
-    canceled_status: normalizeStatusId(workflow?.canceled_status)
-  };
-}
-function appendTypeWorkflowPair(record, pair) {
-  if (!Array.isArray(pair) || pair.length !== 2) {
-    return;
-  }
-  const from = normalizeStatusToken(pair[0]);
-  const to = normalizeStatusToken(pair[1]);
-  if (from.length === 0 || to.length === 0) {
-    return;
-  }
-  if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
-    return;
-  }
-  record.pairs.push([from, to]);
+  record.pairs.push([from, to]);
 }
 function normalizedTypeWorkflowEntry(entry) {
   const rawType = typeof entry?.type === "string" ? entry.type.trim() : "";
@@ -5614,1622 +5481,6 @@ function statusIsTerminal(status, registry) {
   return registry.terminal_statuses.has(normalized);
 }
 
-// dist/core/shared/errors.js
-var PmCliError = class extends Error {
-  exitCode;
-  context;
-  constructor(message, exitCode, context = {}) {
-    super(message);
-    this.name = "PmCliError";
-    this.exitCode = exitCode;
-    this.context = context;
-  }
-};
-
-// dist/core/shared/serialization.js
-import crypto2 from "node:crypto";
-function sortScalarValue(value) {
-  if (value === null)
-    return null;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (typeof value === "symbol") {
-    return value.toString();
-  }
-  if (typeof value === "function") {
-    return `[function:${value.name || "anonymous"}]`;
-  }
-  return void 0;
-}
-function sortPlainObjectKeys(value) {
-  const sortedKeys = Object.keys(value).sort();
-  const result = {};
-  for (const key of sortedKeys) {
-    const nested = value[key];
-    if (nested === void 0) {
-      continue;
-    }
-    result[key] = sortObjectKeys(nested);
-  }
-  return result;
-}
-function sortObjectKeys(value) {
-  const scalarValue = sortScalarValue(value);
-  if (scalarValue !== void 0) {
-    return scalarValue;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => sortObjectKeys(entry));
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  const maybeJson = value;
-  if (typeof maybeJson.toJSON === "function") {
-    const normalized = maybeJson.toJSON();
-    if (normalized !== value) {
-      return sortObjectKeys(normalized);
-    }
-  }
-  return sortPlainObjectKeys(value);
-}
-function stableStringify(value) {
-  return JSON.stringify(sortObjectKeys(value));
-}
-function hasUnmatchedEquivalent(leftValue, rightValues, matchedIndexes, equals) {
-  for (let index = 0; index < rightValues.length; index += 1) {
-    if (matchedIndexes.has(index)) {
-      continue;
-    }
-    if (equals(leftValue, rightValues[index])) {
-      matchedIndexes.add(index);
-      return true;
-    }
-  }
-  return false;
-}
-function compareRegExpValues(left, right) {
-  if (!(left instanceof RegExp || right instanceof RegExp)) {
-    return void 0;
-  }
-  return left instanceof RegExp && right instanceof RegExp && left.toString() === right.toString();
-}
-function compareDateValues(left, right) {
-  if (!(left instanceof Date || right instanceof Date)) {
-    return void 0;
-  }
-  return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
-}
-function compareSetValues(left, right) {
-  if (!(left instanceof Set || right instanceof Set)) {
-    return void 0;
-  }
-  if (!(left instanceof Set && right instanceof Set) || left.size !== right.size) {
-    return false;
-  }
-  const rightValues = [...right];
-  const matched = /* @__PURE__ */ new Set();
-  for (const leftValue of left) {
-    if (!hasUnmatchedEquivalent(leftValue, rightValues, matched, stableValueEquals)) {
-      return false;
-    }
-  }
-  return true;
-}
-function compareMapValues(left, right) {
-  if (!(left instanceof Map || right instanceof Map)) {
-    return void 0;
-  }
-  if (!(left instanceof Map && right instanceof Map) || left.size !== right.size) {
-    return false;
-  }
-  const rightEntries = [...right.entries()];
-  const matched = /* @__PURE__ */ new Set();
-  for (const [leftKey, leftValue] of left.entries()) {
-    const leftEntry = [leftKey, leftValue];
-    if (!hasUnmatchedEquivalent(leftEntry, rightEntries, matched, ([candidateKey, candidateValue], [rightKey, rightValue]) => stableValueEquals(candidateKey, rightKey) && stableValueEquals(candidateValue, rightValue))) {
-      return false;
-    }
-  }
-  return true;
-}
-function compareArrayValues(left, right) {
-  if (!(Array.isArray(left) || Array.isArray(right))) {
-    return void 0;
-  }
-  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
-    return false;
-  }
-  return left.every((value, index) => stableValueEquals(value, right[index]));
-}
-function comparePlainObjectValues(left, right) {
-  const leftKeys = Object.keys(left).sort((a, b) => a.localeCompare(b));
-  const rightKeys = Object.keys(right).sort((a, b) => a.localeCompare(b));
-  if (leftKeys.length !== rightKeys.length) {
-    return false;
-  }
-  for (let index = 0; index < leftKeys.length; index += 1) {
-    const leftKey = leftKeys[index];
-    if (leftKey !== rightKeys[index]) {
-      return false;
-    }
-    if (!stableValueEquals(left[leftKey], right[leftKey])) {
-      return false;
-    }
-  }
-  return true;
-}
-var SPECIALIZED_STABLE_VALUE_COMPARISONS = [
-  compareRegExpValues,
-  compareDateValues,
-  compareSetValues,
-  compareMapValues,
-  compareArrayValues
-];
-function stableValueEquals(left, right) {
-  if (Object.is(left, right)) {
-    return true;
-  }
-  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
-    return false;
-  }
-  for (const compare of SPECIALIZED_STABLE_VALUE_COMPARISONS) {
-    const result = compare(left, right);
-    if (result !== void 0) {
-      return result;
-    }
-  }
-  return comparePlainObjectValues(left, right);
-}
-function sha256Hex(value) {
-  return crypto2.createHash("sha256").update(value, "utf8").digest("hex");
-}
-function orderObject(value, keyOrder) {
-  const ordered = {};
-  for (const key of keyOrder) {
-    const entry = value[key];
-    if (entry !== void 0) {
-      ordered[key] = entry;
-    }
-  }
-  const unknownKeys = Object.keys(value).filter((key) => !keyOrder.includes(key)).sort((a, b) => a.localeCompare(b));
-  for (const key of unknownKeys) {
-    const entry = value[key];
-    if (entry !== void 0) {
-      ordered[key] = entry;
-    }
-  }
-  return ordered;
-}
-
-// dist/core/store/settings-validator.js
-var FAIL = { ok: false };
-var vString = (input) => typeof input === "string" ? { ok: true, value: input } : FAIL;
-var vBoolean = (input) => typeof input === "boolean" ? { ok: true, value: input } : FAIL;
-function vNumber(options = {}) {
-  return (input) => {
-    if (typeof input !== "number" || !Number.isFinite(input)) {
-      return FAIL;
-    }
-    if (options.int && (!Number.isInteger(input) || !Number.isSafeInteger(input))) {
-      return FAIL;
-    }
-    if (options.positive && input <= 0) {
-      return FAIL;
-    }
-    return { ok: true, value: input };
-  };
-}
-function vLiteral(...allowed) {
-  return (input) => typeof input === "string" && allowed.includes(input) ? { ok: true, value: input } : FAIL;
-}
-function vArray(item) {
-  return (input) => {
-    if (!Array.isArray(input)) {
-      return FAIL;
-    }
-    const value = [];
-    for (const element of input) {
-      const result = item(element);
-      if (!result.ok) {
-        return FAIL;
-      }
-      value.push(result.value);
-    }
-    return { ok: true, value };
-  };
-}
-function vOptional(inner) {
-  return (input) => input === void 0 ? { ok: true, value: void 0 } : inner(input);
-}
-function vRecordOf(valueCheck) {
-  return (input) => {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      return FAIL;
-    }
-    const value = {};
-    for (const [key, raw] of Object.entries(input)) {
-      const result = valueCheck(raw);
-      if (!result.ok) {
-        return FAIL;
-      }
-      value[key] = result.value;
-    }
-    return { ok: true, value };
-  };
-}
-function vObject(shape) {
-  return (input) => {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      return FAIL;
-    }
-    const record = input;
-    const value = {};
-    for (const [key, check] of Object.entries(shape)) {
-      const result = check(record[key]);
-      if (!result.ok) {
-        return FAIL;
-      }
-      if (result.value !== void 0) {
-        value[key] = result.value;
-      }
-    }
-    return { ok: true, value };
-  };
-}
-var itemTypeOption = vObject({
-  key: vString,
-  values: vArray(vString),
-  required: vOptional(vBoolean),
-  aliases: vOptional(vArray(vString)),
-  description: vOptional(vString)
-});
-var itemTypeCommandOptionPolicy = vObject({
-  command: vLiteral("create", "update"),
-  option: vString,
-  required: vOptional(vBoolean),
-  visible: vOptional(vBoolean),
-  enabled: vOptional(vBoolean)
-});
-var itemTypeDefinition = vObject({
-  name: vString,
-  description: vOptional(vString),
-  // Per-type create-time default status (config-driven); preserved so inline
-  // settings.item_types.definitions behave identically to schema/types.json.
-  default_status: vOptional(vString),
-  folder: vOptional(vString),
-  aliases: vOptional(vArray(vString)),
-  required_create_fields: vOptional(vArray(vString)),
-  required_create_repeatables: vOptional(vArray(vString)),
-  options: vOptional(vArray(itemTypeOption)),
-  command_option_policies: vOptional(vArray(itemTypeCommandOptionPolicy))
-});
-var runtimeStatusDefinition = vObject({
-  id: vString,
-  aliases: vOptional(vArray(vString)),
-  roles: vOptional(vArray(vLiteral(...RUNTIME_STATUS_ROLE_VALUES))),
-  description: vOptional(vString),
-  order: vOptional(vNumber())
-});
-var runtimeFieldDefinition = vObject({
-  key: vString,
-  metadata_key: vOptional(vString),
-  front_matter_key: vOptional(vString),
-  cli_flag: vOptional(vString),
-  cli_aliases: vOptional(vArray(vString)),
-  description: vOptional(vString),
-  type: vOptional(vLiteral(...RUNTIME_FIELD_TYPE_VALUES)),
-  commands: vOptional(vArray(vLiteral(...RUNTIME_FIELD_COMMAND_VALUES))),
-  repeatable: vOptional(vBoolean),
-  required: vOptional(vBoolean),
-  required_on_create: vOptional(vBoolean),
-  required_types: vOptional(vArray(vString)),
-  allow_unset: vOptional(vBoolean)
-});
-var statusTransitionPair = (input) => {
-  if (!Array.isArray(input) || input.length !== 2) {
-    return FAIL;
-  }
-  const [from, to] = input;
-  if (typeof from !== "string" || typeof to !== "string") {
-    return FAIL;
-  }
-  return { ok: true, value: [from, to] };
-};
-var typeWorkflowDefinition = vObject({
-  type: vString,
-  allowed_transitions: vArray(statusTransitionPair)
-});
-var runtimeSchemaSettings = vOptional(vObject({
-  version: vOptional(vNumber({ int: true })),
-  files: vOptional(vObject({
-    types: vOptional(vString),
-    statuses: vOptional(vString),
-    fields: vOptional(vString),
-    workflows: vOptional(vString)
-  })),
-  statuses: vOptional(vArray(runtimeStatusDefinition)),
-  fields: vOptional(vArray(runtimeFieldDefinition)),
-  workflow: vOptional(vObject({
-    draft_status: vOptional(vString),
-    open_status: vOptional(vString),
-    in_progress_status: vOptional(vString),
-    blocked_status: vOptional(vString),
-    close_status: vOptional(vString),
-    canceled_status: vOptional(vString)
-  })),
-  type_workflows: vOptional(vArray(typeWorkflowDefinition)),
-  unknown_field_policy: vOptional(vLiteral(...RUNTIME_UNKNOWN_FIELD_POLICY_VALUES))
-}));
-var governanceSettings = vOptional(vObject({
-  preset: vOptional(vLiteral(...GOVERNANCE_PRESET_VALUES)),
-  ownership_enforcement: vOptional(vLiteral("none", "warn", "strict")),
-  create_mode_default: vOptional(vLiteral("progressive", "strict")),
-  close_validation_default: vOptional(vLiteral("off", "warn", "strict")),
-  require_close_reason: vOptional(vBoolean),
-  parent_reference: vOptional(vLiteral("warn", "strict_error")),
-  metadata_profile: vOptional(vLiteral("core", "strict", "custom")),
-  force_required_for_stale_lock: vOptional(vBoolean),
-  create_default_type: vOptional(vString),
-  workflow_enforcement: vOptional(vLiteral("off", "warn", "strict"))
-}));
-var extensionPolicyOverride = vObject({
-  name: vString,
-  disabled: vOptional(vBoolean),
-  require_trusted: vOptional(vBoolean),
-  require_provenance: vOptional(vBoolean),
-  sandbox_profile: vOptional(vLiteral("none", "restricted", "strict")),
-  allowed_capabilities: vOptional(vArray(vString)),
-  blocked_capabilities: vOptional(vArray(vString)),
-  allowed_surfaces: vOptional(vArray(vString)),
-  blocked_surfaces: vOptional(vArray(vString)),
-  allowed_commands: vOptional(vArray(vString)),
-  blocked_commands: vOptional(vArray(vString)),
-  allowed_actions: vOptional(vArray(vString)),
-  blocked_actions: vOptional(vArray(vString)),
-  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")),
-  allowed_extensions: vOptional(vArray(vString)),
-  blocked_extensions: vOptional(vArray(vString)),
-  allowed_capabilities: vOptional(vArray(vString)),
-  blocked_capabilities: vOptional(vArray(vString)),
-  allowed_surfaces: vOptional(vArray(vString)),
-  blocked_surfaces: vOptional(vArray(vString)),
-  allowed_commands: vOptional(vArray(vString)),
-  blocked_commands: vOptional(vArray(vString)),
-  allowed_actions: vOptional(vArray(vString)),
-  blocked_actions: vOptional(vArray(vString)),
-  allowed_services: vOptional(vArray(vString)),
-  blocked_services: vOptional(vArray(vString)),
-  extension_overrides: vOptional(vArray(extensionPolicyOverride))
-}));
-var settingsCheck = vObject({
-  version: vNumber({ int: true }),
-  id_prefix: vString,
-  author_default: vString,
-  item_format: vOptional(vLiteral("toon", "json_markdown")),
-  locks: vObject({ ttl_seconds: vNumber({ int: true }) }),
-  checkpoints: vOptional(vObject({ retention_days: vOptional(vNumber({ int: true, positive: true })) })),
-  output: vObject({ default_format: vLiteral("toon", "json") }),
-  history: vOptional(vObject({
-    missing_stream: vLiteral("auto_create", "strict_error"),
-    compact_policy: vOptional(vObject({
-      enabled: vOptional(vBoolean),
-      max_entries: vOptional(vNumber({ int: true, positive: true })),
-      trigger: vOptional(vLiteral("health_warn", "auto"))
-    }))
-  })),
-  validation: vOptional(vObject({
-    sprint_release_format: vLiteral("warn", "strict_error"),
-    parent_reference: vOptional(vLiteral("warn", "strict_error")),
-    metadata_profile: vOptional(vLiteral("core", "strict", "custom")),
-    metadata_required_fields: vOptional(vArray(vString)),
-    lifecycle_stale_blocker_reason_patterns: vOptional(vArray(vString)),
-    lifecycle_closure_like_blocked_reason_patterns: vOptional(vArray(vString)),
-    lifecycle_closure_like_resolution_patterns: vOptional(vArray(vString)),
-    lifecycle_closure_like_actual_result_patterns: vOptional(vArray(vString)),
-    estimate_defaults_by_type: vOptional(vRecordOf(vNumber({ int: true, positive: true })))
-  })),
-  governance: governanceSettings,
-  workflow: vOptional(vObject({ definition_of_done: vArray(vString) })),
-  testing: vOptional(vObject({ record_results_to_items: vBoolean })),
-  telemetry: vOptional(vObject({
-    enabled: vBoolean,
-    first_run_prompt_completed: vOptional(vBoolean),
-    capture_level: vOptional(vLiteral("minimal", "redacted", "max")),
-    endpoint: vOptional(vString),
-    installation_id: vOptional(vString),
-    retention_days: vOptional(vNumber({ int: true, positive: true }))
-  })),
-  agent_guidance: vOptional(vObject({
-    prompt_completed: vOptional(vBoolean),
-    declined: vOptional(vBoolean),
-    declined_at: vOptional(vString),
-    template_version: vOptional(vNumber({ int: true, positive: true })),
-    last_checked_files: vOptional(vArray(vString))
-  })),
-  item_types: vOptional(vObject({ definitions: vArray(itemTypeDefinition) })),
-  schema: runtimeSchemaSettings,
-  context: vOptional(vObject({
-    default_depth: vOptional(vLiteral("brief", "standard", "deep")),
-    activity_limit: vOptional(vNumber({ int: true, positive: true })),
-    stale_threshold_days: vOptional(vNumber({ int: true, positive: true })),
-    sections: vOptional(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),
-      staleness: vOptional(vBoolean),
-      tests: vOptional(vBoolean)
-    }))
-  })),
-  extensions: vObject({
-    enabled: vArray(vString),
-    disabled: vArray(vString),
-    policy: extensionPolicy
-  }),
-  search: vObject({
-    score_threshold: vNumber(),
-    hybrid_semantic_weight: vOptional(vNumber()),
-    max_results: vNumber({ int: true }),
-    embedding_model: vString,
-    embedding_corpus_max_characters: vOptional(vNumber()),
-    embedding_batch_size: vNumber({ int: true }),
-    embedding_timeout_ms: vOptional(vNumber({ int: true })),
-    scanner_max_batch_retries: vNumber({ int: true }),
-    provider: vOptional(vString),
-    corpus_fields: vOptional(vArray(vString)),
-    mutation_refresh_policy: vOptional(vLiteral("cache_only", "semantic_configured", "semantic_auto")),
-    query_expansion: vOptional(vObject({
-      enabled: vOptional(vBoolean),
-      provider: vOptional(vString)
-    })),
-    rerank: vOptional(vObject({
-      enabled: vOptional(vBoolean),
-      model: vOptional(vString),
-      top_k: vOptional(vNumber({ int: true, positive: true }))
-    })),
-    // pm-75k9: offline BM25 tuning. Unlike `search.tuning` (intentionally
-    // stripped for legacy zod parity), bm25 is validated so it persists across
-    // writeSettings round-trips — these knobs must survive to take effect.
-    bm25: vOptional(vObject({
-      k1: vOptional(vNumber()),
-      b: vOptional(vNumber())
-    }))
-  }),
-  providers: vObject({
-    openai: vObject({ base_url: vString, api_key: vString, model: vString }),
-    ollama: vObject({ base_url: vString, model: vString })
-  }),
-  vector_store: vObject({
-    adapter: vOptional(vString),
-    collection_name: vOptional(vString),
-    qdrant: vObject({ url: vString, api_key: vString }),
-    lancedb: vObject({ path: vString })
-  })
-});
-function validateSettings(raw) {
-  const result = settingsCheck(raw);
-  if (!result.ok) {
-    return { success: false };
-  }
-  return { success: true, data: result.value };
-}
-
-// dist/core/validate/estimate-defaults.js
-var DEFAULT_ESTIMATE_MINUTES_BY_TYPE = {
-  Epic: 2880,
-  Feature: 480,
-  Story: 480,
-  Milestone: 2880,
-  Task: 120,
-  Issue: 60,
-  Bug: 60,
-  Chore: 30,
-  Decision: 15,
-  Plan: 120
-};
-var FALLBACK_ESTIMATE_MINUTES = 120;
-function isHonoredMinutes(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-function toLowercasedLookup(source) {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(source)) {
-    lookup.set(key.toLowerCase(), value);
-  }
-  return lookup;
-}
-var BUILTIN_LOWERCASED_LOOKUP = toLowercasedLookup(DEFAULT_ESTIMATE_MINUTES_BY_TYPE);
-var OVERRIDE_LOOKUP_CACHE = /* @__PURE__ */ new WeakMap();
-function lowercasedOverrideLookup(overrides) {
-  const cached = OVERRIDE_LOOKUP_CACHE.get(overrides);
-  if (cached) {
-    return cached;
-  }
-  const lookup = toLowercasedLookup(overrides);
-  OVERRIDE_LOOKUP_CACHE.set(overrides, lookup);
-  return lookup;
-}
-function resolveEstimateDefaultMinutes(type, overrides) {
-  const key = (type ?? "").trim().toLowerCase();
-  if (key.length === 0) {
-    return FALLBACK_ESTIMATE_MINUTES;
-  }
-  if (overrides) {
-    const overrideValue = lowercasedOverrideLookup(overrides).get(key);
-    if (isHonoredMinutes(overrideValue)) {
-      return Math.floor(overrideValue);
-    }
-  }
-  const builtinValue = BUILTIN_LOWERCASED_LOOKUP.get(key);
-  if (isHonoredMinutes(builtinValue)) {
-    return Math.floor(builtinValue);
-  }
-  return FALLBACK_ESTIMATE_MINUTES;
-}
-function normalizeEstimateDefaultOverrides(raw) {
-  const normalized = {};
-  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
-    return normalized;
-  }
-  for (const [rawKey, rawValue] of Object.entries(raw)) {
-    const key = rawKey.trim();
-    if (key.length === 0 || !isHonoredMinutes(rawValue)) {
-      continue;
-    }
-    normalized[key] = Math.floor(rawValue);
-  }
-  return normalized;
-}
-
-// 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");
-var MAX_VECTOR_STORE_COLLECTION_NAME_LENGTH = 128;
-function resolveGovernanceKnobsFromPreset(preset) {
-  return structuredClone(GOVERNANCE_PRESET_DEFAULTS[preset]);
-}
-function normalizeGovernancePreset(value) {
-  if (value === "minimal" || value === "default" || value === "strict" || value === "custom") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.governance.preset;
-}
-function withGovernanceExtras(base, governance) {
-  const createDefaultType = typeof governance.create_default_type === "string" ? governance.create_default_type.trim() : void 0;
-  if (createDefaultType && createDefaultType.length > 0) {
-    base.create_default_type = createDefaultType;
-  }
-  if (governance.workflow_enforcement === "off" || governance.workflow_enforcement === "warn" || governance.workflow_enforcement === "strict") {
-    base.workflow_enforcement = governance.workflow_enforcement;
-  }
-  if (governance.require_close_reason === false) {
-    base.require_close_reason = false;
-  }
-  return base;
-}
-function normalizeGovernanceForPersist(governance) {
-  if (governance.preset === "custom") {
-    return withGovernanceExtras({
-      preset: "custom",
-      ownership_enforcement: governance.ownership_enforcement,
-      create_mode_default: governance.create_mode_default,
-      close_validation_default: governance.close_validation_default,
-      parent_reference: governance.parent_reference,
-      metadata_profile: governance.metadata_profile,
-      force_required_for_stale_lock: governance.force_required_for_stale_lock
-    }, governance);
-  }
-  return withGovernanceExtras({
-    preset: governance.preset
-  }, governance);
-}
-function resolveGovernanceExtras(rawGovernance) {
-  const createDefaultType = typeof rawGovernance.create_default_type === "string" ? rawGovernance.create_default_type.trim() : void 0;
-  const extras = {};
-  if (createDefaultType && createDefaultType.length > 0) {
-    extras.create_default_type = createDefaultType;
-  }
-  if (rawGovernance.workflow_enforcement === "off" || rawGovernance.workflow_enforcement === "warn" || rawGovernance.workflow_enforcement === "strict") {
-    extras.workflow_enforcement = rawGovernance.workflow_enforcement;
-  }
-  if (typeof rawGovernance.require_close_reason === "boolean") {
-    extras.require_close_reason = rawGovernance.require_close_reason;
-  }
-  return extras;
-}
-function resolveGovernanceKnobs(settings) {
-  const rawGovernance = settings.governance ?? {};
-  const preset = normalizeGovernancePreset(rawGovernance.preset);
-  const extras = resolveGovernanceExtras(rawGovernance);
-  if (preset === "custom") {
-    const baseline2 = resolveGovernanceKnobsFromPreset("default");
-    const requireCloseReason2 = extras.require_close_reason ?? baseline2.require_close_reason;
-    return {
-      preset,
-      ownership_enforcement: rawGovernance.ownership_enforcement ?? baseline2.ownership_enforcement,
-      create_mode_default: rawGovernance.create_mode_default ?? baseline2.create_mode_default,
-      close_validation_default: rawGovernance.close_validation_default ?? baseline2.close_validation_default,
-      parent_reference: rawGovernance.parent_reference ?? baseline2.parent_reference,
-      metadata_profile: rawGovernance.metadata_profile ?? baseline2.metadata_profile,
-      force_required_for_stale_lock: rawGovernance.force_required_for_stale_lock ?? baseline2.force_required_for_stale_lock,
-      ...extras,
-      require_close_reason: requireCloseReason2
-    };
-  }
-  const baseline = resolveGovernanceKnobsFromPreset(preset);
-  const requireCloseReason = extras.require_close_reason ?? baseline.require_close_reason;
-  return {
-    preset,
-    ...baseline,
-    ...extras,
-    require_close_reason: requireCloseReason
-  };
-}
-function cloneDefaults() {
-  return structuredClone(SETTINGS_DEFAULTS);
-}
-function normalizeSearchMutationRefreshPolicy(value) {
-  if (value === "cache_only" || value === "semantic_configured" || value === "semantic_auto") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.mutation_refresh_policy;
-}
-function normalizeSearchQueryExpansionEnabled(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.query_expansion.enabled;
-}
-function normalizeSearchQueryExpansionProvider(value) {
-  if (typeof value !== "string") {
-    return SETTINGS_DEFAULTS.search.query_expansion.provider;
-  }
-  return value.trim();
-}
-function normalizeSearchRerankEnabled(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.rerank.enabled;
-}
-function normalizeSearchRerankModel(value) {
-  if (typeof value !== "string") {
-    return SETTINGS_DEFAULTS.search.rerank.model;
-  }
-  return value.trim();
-}
-function normalizeSearchRerankTopK(value) {
-  if (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0) {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.search.rerank.top_k;
-}
-function normalizeVectorStoreCollectionName(value) {
-  if (typeof value !== "string") {
-    return SETTINGS_DEFAULTS.vector_store.collection_name;
-  }
-  const sanitized = value.trim().replaceAll(/[^a-zA-Z0-9_-]/g, "_");
-  const truncated = sanitized.slice(0, MAX_VECTOR_STORE_COLLECTION_NAME_LENGTH);
-  return truncated.length > 0 ? truncated : SETTINGS_DEFAULTS.vector_store.collection_name;
-}
-function buildSettingsPersistSourceSnapshot(parsedSettings, runtimeSettings) {
-  const sourceSchema = parsedSettings.schema;
-  const sourceStatuses = Array.isArray(sourceSchema?.statuses) ? sourceSchema?.statuses : void 0;
-  const sourceFields = Array.isArray(sourceSchema?.fields) ? sourceSchema?.fields : void 0;
-  const sourceTypeWorkflows = Array.isArray(sourceSchema?.type_workflows) ? sourceSchema?.type_workflows : void 0;
-  return {
-    has_source_item_type_definitions: Array.isArray(parsedSettings.item_types?.definitions),
-    source_item_type_definitions: normalizeItemTypeDefinitions(parsedSettings.item_types?.definitions),
-    has_source_schema_statuses: sourceStatuses !== void 0,
-    source_schema_statuses: sourceStatuses ? structuredClone(sourceStatuses) : [],
-    has_source_schema_fields: sourceFields !== void 0,
-    source_schema_fields: sourceFields ? structuredClone(sourceFields) : [],
-    has_source_schema_type_workflows: sourceTypeWorkflows !== void 0,
-    source_schema_type_workflows: sourceTypeWorkflows ? structuredClone(sourceTypeWorkflows) : [],
-    runtime_item_type_definitions: normalizeItemTypeDefinitions(runtimeSettings.item_types?.definitions),
-    runtime_schema_statuses: structuredClone(runtimeSettings.schema.statuses),
-    runtime_schema_fields: structuredClone(runtimeSettings.schema.fields),
-    runtime_schema_type_workflows: structuredClone(runtimeSettings.schema.type_workflows ?? [])
-  };
-}
-function attachSettingsPersistSourceSnapshot(settings, source) {
-  Object.defineProperty(settings, SETTINGS_PERSIST_SOURCE_SYMBOL, {
-    value: source,
-    writable: true,
-    configurable: true,
-    enumerable: false
-  });
-}
-function getSettingsPersistSourceSnapshot(settings) {
-  const candidate = settings[SETTINGS_PERSIST_SOURCE_SYMBOL];
-  if (!candidate || typeof candidate !== "object") {
-    return void 0;
-  }
-  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);
-  if (!source) {
-    return {
-      item_type_definitions: currentItemTypeDefinitions,
-      schema_statuses: normalizedSchema.statuses,
-      schema_fields: normalizedSchema.fields,
-      schema_type_workflows: normalizedSchema.type_workflows
-    };
-  }
-  const currentTypeWorkflows = normalizedSchema.type_workflows ?? [];
-  const itemTypeDefinitionsUnchanged = stableValueEquals(currentItemTypeDefinitions, source.runtime_item_type_definitions);
-  const schemaStatusesUnchanged = stableValueEquals(normalizedSchema.statuses, source.runtime_schema_statuses);
-  const schemaFieldsUnchanged = stableValueEquals(normalizedSchema.fields, source.runtime_schema_fields);
-  const schemaTypeWorkflowsUnchanged = stableValueEquals(currentTypeWorkflows, source.runtime_schema_type_workflows);
-  return {
-    item_type_definitions: itemTypeDefinitionsUnchanged ? source.has_source_item_type_definitions ? normalizeItemTypeDefinitions(source.source_item_type_definitions) : [] : currentItemTypeDefinitions,
-    schema_statuses: schemaStatusesUnchanged ? source.has_source_schema_statuses ? structuredClone(source.source_schema_statuses) : [] : normalizedSchema.statuses,
-    schema_fields: schemaFieldsUnchanged ? source.has_source_schema_fields ? structuredClone(source.source_schema_fields) : [] : normalizedSchema.fields,
-    schema_type_workflows: schemaTypeWorkflowsUnchanged ? source.has_source_schema_type_workflows ? structuredClone(source.source_schema_type_workflows) : void 0 : normalizedSchema.type_workflows
-  };
-}
-function buildFallbackSettingsReadResult(warning) {
-  return {
-    settings: cloneDefaults(),
-    metadata: {
-      has_explicit_item_format: false
-    },
-    warnings: warning ? [warning] : []
-  };
-}
-function hasExplicitItemFormat(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    return false;
-  }
-  const itemFormat = raw.item_format;
-  return itemFormat === "toon" || itemFormat === "json_markdown";
-}
-function normalizeStringList2(values) {
-  return [...new Set((values ?? []).map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeAgentGuidanceSettings(value) {
-  const defaults = SETTINGS_DEFAULTS.agent_guidance;
-  const templateVersion = value?.template_version;
-  return {
-    prompt_completed: value?.prompt_completed === true,
-    declined: value?.declined === true,
-    declined_at: typeof value?.declined_at === "string" ? value.declined_at : defaults.declined_at,
-    template_version: typeof templateVersion === "number" && Number.isInteger(templateVersion) && templateVersion > 0 ? templateVersion : defaults.template_version,
-    last_checked_files: normalizeStringList2(value?.last_checked_files ?? defaults.last_checked_files)
-  };
-}
-function normalizeLowerStringList(values) {
-  return [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeExtensionPolicyMode(value) {
-  if (value === "off" || value === "warn" || value === "enforce") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.extensions.policy.mode;
-}
-function normalizeExtensionTrustMode(value) {
-  if (value === "off" || value === "warn" || value === "enforce") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.extensions.policy.trust_mode;
-}
-function normalizeExtensionSandboxProfile(value) {
-  if (value === "none" || value === "restricted" || value === "strict") {
-    return value;
-  }
-  return SETTINGS_DEFAULTS.extensions.policy.default_sandbox_profile;
-}
-function normalizeExtensionPolicyOverride(override) {
-  const name = override.name.trim().toLowerCase();
-  if (name.length === 0) {
-    return null;
-  }
-  const normalized = {
-    name
-  };
-  if (override.disabled === true) {
-    normalized.disabled = true;
-  }
-  if (override.require_trusted === true) {
-    normalized.require_trusted = true;
-  }
-  if (override.require_provenance === true) {
-    normalized.require_provenance = true;
-  }
-  if (override.sandbox_profile !== void 0) {
-    normalized.sandbox_profile = normalizeExtensionSandboxProfile(override.sandbox_profile);
-  }
-  const allowedCapabilities = normalizeLowerStringList(override.allowed_capabilities);
-  const blockedCapabilities = normalizeLowerStringList(override.blocked_capabilities);
-  const allowedSurfaces = normalizeLowerStringList(override.allowed_surfaces);
-  const blockedSurfaces = normalizeLowerStringList(override.blocked_surfaces);
-  const allowedCommands = normalizeLowerStringList(override.allowed_commands);
-  const blockedCommands = normalizeLowerStringList(override.blocked_commands);
-  const allowedActions = normalizeLowerStringList(override.allowed_actions);
-  const blockedActions = normalizeLowerStringList(override.blocked_actions);
-  const allowedServices = normalizeLowerStringList(override.allowed_services);
-  const blockedServices = normalizeLowerStringList(override.blocked_services);
-  if (allowedCapabilities.length > 0) {
-    normalized.allowed_capabilities = allowedCapabilities;
-  }
-  if (blockedCapabilities.length > 0) {
-    normalized.blocked_capabilities = blockedCapabilities;
-  }
-  if (allowedSurfaces.length > 0) {
-    normalized.allowed_surfaces = allowedSurfaces;
-  }
-  if (blockedSurfaces.length > 0) {
-    normalized.blocked_surfaces = blockedSurfaces;
-  }
-  if (allowedCommands.length > 0) {
-    normalized.allowed_commands = allowedCommands;
-  }
-  if (blockedCommands.length > 0) {
-    normalized.blocked_commands = blockedCommands;
-  }
-  if (allowedActions.length > 0) {
-    normalized.allowed_actions = allowedActions;
-  }
-  if (blockedActions.length > 0) {
-    normalized.blocked_actions = blockedActions;
-  }
-  if (allowedServices.length > 0) {
-    normalized.allowed_services = allowedServices;
-  }
-  if (blockedServices.length > 0) {
-    normalized.blocked_services = blockedServices;
-  }
-  return normalized;
-}
-function normalizeExtensionPolicyOverrides(overrides) {
-  const dedupedByName = /* @__PURE__ */ new Map();
-  for (const override of overrides ?? []) {
-    const normalized = normalizeExtensionPolicyOverride(override);
-    if (!normalized) {
-      continue;
-    }
-    dedupedByName.set(normalized.name, normalized);
-  }
-  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 normalizeExtensionPolicyList(policy, key) {
-  return normalizeLowerStringList(policy?.[key] ?? SETTINGS_DEFAULTS.extensions.policy[key]);
-}
-function normalizeExtensionPolicySettings(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: normalizeExtensionPolicyList(policy, "trusted_extensions"),
-    default_sandbox_profile: normalizeExtensionSandboxProfile(policy?.default_sandbox_profile),
-    allowed_extensions: normalizeExtensionPolicyList(policy, "allowed_extensions"),
-    blocked_extensions: normalizeExtensionPolicyList(policy, "blocked_extensions"),
-    allowed_capabilities: normalizeExtensionPolicyList(policy, "allowed_capabilities"),
-    blocked_capabilities: normalizeExtensionPolicyList(policy, "blocked_capabilities"),
-    allowed_surfaces: normalizeExtensionPolicyList(policy, "allowed_surfaces"),
-    blocked_surfaces: normalizeExtensionPolicyList(policy, "blocked_surfaces"),
-    allowed_commands: normalizeExtensionPolicyList(policy, "allowed_commands"),
-    blocked_commands: normalizeExtensionPolicyList(policy, "blocked_commands"),
-    allowed_actions: normalizeExtensionPolicyList(policy, "allowed_actions"),
-    blocked_actions: normalizeExtensionPolicyList(policy, "blocked_actions"),
-    allowed_services: normalizeExtensionPolicyList(policy, "allowed_services"),
-    blocked_services: normalizeExtensionPolicyList(policy, "blocked_services"),
-    extension_overrides: normalizeExtensionPolicyOverrides(policy?.extension_overrides ?? SETTINGS_DEFAULTS.extensions.policy.extension_overrides)
-  };
-}
-function normalizeValidationMetadataRequiredFields(values) {
-  const normalized = [...new Set((values ?? []).map((value) => value.trim().toLowerCase().replaceAll("-", "_")))].filter((value) => value.length > 0).sort((left, right) => left.localeCompare(right));
-  return normalized.filter((value) => [
-    "author",
-    "acceptance_criteria",
-    "estimated_minutes",
-    "close_reason",
-    "reviewer",
-    "risk",
-    "confidence",
-    "sprint",
-    "release"
-  ].includes(value));
-}
-function normalizeValidationPatternList(values) {
-  return [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function valueOrDefault(value, fallback) {
-  return value === void 0 ? fallback : value;
-}
-function recordOrEmpty(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
-}
-function arrayOrEmpty(value) {
-  return Array.isArray(value) ? value : [];
-}
-function buildValidationSettings(settings, defaults, governance) {
-  return {
-    ...defaults.validation,
-    ...settings.validation,
-    parent_reference: governance.parent_reference,
-    metadata_profile: governance.metadata_profile,
-    metadata_required_fields: normalizeValidationMetadataRequiredFields(settings.validation?.metadata_required_fields),
-    lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_stale_blocker_reason_patterns ?? defaults.validation.lifecycle_stale_blocker_reason_patterns),
-    lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? defaults.validation.lifecycle_closure_like_blocked_reason_patterns),
-    lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_resolution_patterns ?? defaults.validation.lifecycle_closure_like_resolution_patterns),
-    lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_actual_result_patterns ?? defaults.validation.lifecycle_closure_like_actual_result_patterns),
-    estimate_defaults_by_type: normalizeEstimateDefaultOverrides(settings.validation?.estimate_defaults_by_type)
-  };
-}
-function buildTelemetrySettings(settings, defaults) {
-  return {
-    enabled: settings.telemetry?.enabled ?? defaults.telemetry.enabled,
-    first_run_prompt_completed: settings.telemetry?.first_run_prompt_completed ?? defaults.telemetry.first_run_prompt_completed,
-    capture_level: settings.telemetry?.capture_level ?? defaults.telemetry.capture_level,
-    endpoint: settings.telemetry?.endpoint ?? defaults.telemetry.endpoint,
-    installation_id: settings.telemetry?.installation_id ?? defaults.telemetry.installation_id,
-    retention_days: settings.telemetry?.retention_days ?? defaults.telemetry.retention_days
-  };
-}
-function buildSearchSettings(settings, defaults) {
-  return {
-    ...defaults.search,
-    ...settings.search,
-    mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(settings.search?.mutation_refresh_policy),
-    query_expansion: {
-      ...defaults.search.query_expansion,
-      ...settings.search?.query_expansion,
-      enabled: normalizeSearchQueryExpansionEnabled(settings.search?.query_expansion?.enabled),
-      provider: normalizeSearchQueryExpansionProvider(settings.search?.query_expansion?.provider)
-    },
-    rerank: {
-      ...defaults.search.rerank,
-      ...settings.search?.rerank,
-      enabled: normalizeSearchRerankEnabled(settings.search?.rerank?.enabled),
-      model: normalizeSearchRerankModel(settings.search?.rerank?.model),
-      top_k: normalizeSearchRerankTopK(settings.search?.rerank?.top_k)
-    }
-  };
-}
-function buildVectorStoreSettings(settings, defaults) {
-  return {
-    adapter: settings.vector_store.adapter ?? defaults.vector_store.adapter,
-    collection_name: normalizeVectorStoreCollectionName(settings.vector_store.collection_name),
-    qdrant: { ...defaults.vector_store.qdrant, ...settings.vector_store.qdrant },
-    lancedb: { ...defaults.vector_store.lancedb, ...settings.vector_store.lancedb }
-  };
-}
-function normalizeSettingsItemFormat(settings, defaults) {
-  if (settings.item_format === "json_markdown") {
-    return "toon";
-  }
-  return settings.item_format ?? defaults.item_format;
-}
-function buildContextSettings(settings, defaults) {
-  return {
-    default_depth: settings.context?.default_depth ?? defaults.context.default_depth,
-    activity_limit: settings.context?.activity_limit ?? defaults.context.activity_limit,
-    stale_threshold_days: settings.context?.stale_threshold_days ?? defaults.context.stale_threshold_days,
-    sections: {
-      ...defaults.context.sections,
-      ...settings.context?.sections
-    }
-  };
-}
-function buildProviderSettings(settings, defaults) {
-  return {
-    openai: { ...defaults.providers.openai, ...settings.providers.openai },
-    ollama: { ...defaults.providers.ollama, ...settings.providers.ollama }
-  };
-}
-function normalizeItemTypeDefinitions(definitions) {
-  const normalized = (definitions ?? []).map((definition) => normalizeItemTypeDefinition(definition)).filter((definition) => definition !== null);
-  const dedupedByName = /* @__PURE__ */ new Map();
-  for (const definition of normalized) {
-    dedupedByName.set(definition.name.toLowerCase(), definition);
-  }
-  return [...dedupedByName.values()].sort((left, right) => left.name.localeCompare(right.name));
-}
-function mergeSettings(settings) {
-  const defaults = cloneDefaults();
-  const governance = resolveGovernanceKnobs({
-    governance: settings.governance ?? { preset: "default" }
-  });
-  return {
-    ...defaults,
-    ...settings,
-    item_format: normalizeSettingsItemFormat(settings, defaults),
-    locks: { ...defaults.locks, ...settings.locks },
-    checkpoints: { ...defaults.checkpoints, ...settings.checkpoints },
-    output: { ...defaults.output, ...settings.output },
-    history: {
-      ...defaults.history,
-      ...settings.history,
-      compact_policy: {
-        ...defaults.history.compact_policy,
-        ...settings.history?.compact_policy
-      }
-    },
-    validation: buildValidationSettings(settings, defaults, governance),
-    governance,
-    workflow: {
-      definition_of_done: [...settings.workflow?.definition_of_done ?? defaults.workflow.definition_of_done]
-    },
-    testing: {
-      record_results_to_items: settings.testing?.record_results_to_items ?? defaults.testing.record_results_to_items
-    },
-    telemetry: buildTelemetrySettings(settings, defaults),
-    agent_guidance: normalizeAgentGuidanceSettings(settings.agent_guidance ?? defaults.agent_guidance),
-    item_types: {
-      definitions: normalizeItemTypeDefinitions(settings.item_types?.definitions)
-    },
-    schema: normalizeRuntimeSchemaSettings(settings.schema ?? defaults.schema),
-    context: buildContextSettings(settings, defaults),
-    extensions: {
-      enabled: [...settings.extensions.enabled],
-      disabled: [...settings.extensions.disabled],
-      policy: normalizeExtensionPolicySettings(settings.extensions.policy ?? defaults.extensions.policy)
-    },
-    search: buildSearchSettings(settings, defaults),
-    providers: buildProviderSettings(settings, defaults),
-    vector_store: buildVectorStoreSettings(settings, defaults)
-  };
-}
-function orderSerializedSettingsSections(ordered) {
-  ordered.locks = orderObject(ordered.locks, ["ttl_seconds"]);
-  ordered.checkpoints = orderObject(ordered.checkpoints, ["retention_days"]);
-  ordered.output = orderObject(ordered.output, ["default_format"]);
-  ordered.history = orderObject(ordered.history, ["missing_stream", "compact_policy"]);
-  ordered.validation = orderObject(ordered.validation, [
-    "sprint_release_format",
-    "parent_reference",
-    "metadata_profile",
-    "metadata_required_fields",
-    "lifecycle_stale_blocker_reason_patterns",
-    "lifecycle_closure_like_blocked_reason_patterns",
-    "lifecycle_closure_like_resolution_patterns",
-    "lifecycle_closure_like_actual_result_patterns",
-    "estimate_defaults_by_type"
-  ]);
-  ordered.governance = orderObject(ordered.governance, [
-    "preset",
-    "ownership_enforcement",
-    "create_mode_default",
-    "close_validation_default",
-    "require_close_reason",
-    "parent_reference",
-    "metadata_profile",
-    "force_required_for_stale_lock",
-    "create_default_type",
-    "workflow_enforcement"
-  ]);
-  ordered.workflow = orderObject(ordered.workflow, ["definition_of_done"]);
-  ordered.testing = orderObject(ordered.testing, ["record_results_to_items"]);
-  ordered.telemetry = orderObject(ordered.telemetry, [
-    "enabled",
-    "first_run_prompt_completed",
-    "capture_level",
-    "endpoint",
-    "installation_id",
-    "retention_days"
-  ]);
-  ordered.agent_guidance = orderObject(ordered.agent_guidance, [
-    "prompt_completed",
-    "declined",
-    "declined_at",
-    "template_version",
-    "last_checked_files"
-  ]);
-  ordered.item_types = orderObject(ordered.item_types, ["definitions"]);
-  ordered.schema = orderObject(ordered.schema, [
-    "version",
-    "files",
-    "statuses",
-    "fields",
-    "workflow",
-    "type_workflows",
-    "unknown_field_policy"
-  ]);
-  ordered.schema.files = orderObject(recordOrEmpty(ordered.schema.files), ["types", "statuses", "fields", "workflows"]);
-  ordered.schema.workflow = orderObject(recordOrEmpty(ordered.schema.workflow), ["draft_status", "open_status", "in_progress_status", "blocked_status", "close_status", "canceled_status"]);
-  ordered.context = orderObject(ordered.context, [
-    "default_depth",
-    "activity_limit",
-    "stale_threshold_days",
-    "sections"
-  ]);
-  ordered.context.sections = orderObject(recordOrEmpty(ordered.context.sections), ["hierarchy", "activity", "progress", "blockers", "files", "workload", "staleness", "tests"]);
-  ordered.extensions = orderObject(ordered.extensions, ["enabled", "disabled", "policy"]);
-  ordered.extensions.policy = orderObject(recordOrEmpty(ordered.extensions.policy), [
-    "mode",
-    "trust_mode",
-    "pm_max_version_exceeded_mode",
-    "require_provenance",
-    "trusted_extensions",
-    "default_sandbox_profile",
-    "allowed_extensions",
-    "blocked_extensions",
-    "allowed_capabilities",
-    "blocked_capabilities",
-    "allowed_surfaces",
-    "blocked_surfaces",
-    "allowed_commands",
-    "blocked_commands",
-    "allowed_actions",
-    "blocked_actions",
-    "allowed_services",
-    "blocked_services",
-    "extension_overrides"
-  ]);
-  ordered.extensions.policy.extension_overrides = arrayOrEmpty(ordered.extensions.policy.extension_overrides).map((entry) => orderObject(recordOrEmpty(entry), [
-    "name",
-    "disabled",
-    "require_trusted",
-    "require_provenance",
-    "sandbox_profile",
-    "allowed_capabilities",
-    "blocked_capabilities",
-    "allowed_surfaces",
-    "blocked_surfaces",
-    "allowed_commands",
-    "blocked_commands",
-    "allowed_actions",
-    "blocked_actions",
-    "allowed_services",
-    "blocked_services"
-  ]));
-  ordered.search = orderObject(ordered.search, [
-    "score_threshold",
-    "hybrid_semantic_weight",
-    "max_results",
-    "embedding_model",
-    "embedding_corpus_max_characters",
-    "embedding_batch_size",
-    "embedding_timeout_ms",
-    "scanner_max_batch_retries",
-    "provider",
-    "mutation_refresh_policy",
-    "query_expansion",
-    "rerank"
-  ]);
-  ordered.search.query_expansion = orderObject(recordOrEmpty(ordered.search.query_expansion), ["enabled", "provider"]);
-  ordered.search.rerank = orderObject(recordOrEmpty(ordered.search.rerank), ["enabled", "model", "top_k"]);
-  ordered.providers = orderObject(ordered.providers, ["openai", "ollama"]);
-  ordered.providers.openai = orderObject(recordOrEmpty(ordered.providers.openai), ["base_url", "api_key", "model"]);
-  ordered.providers.ollama = orderObject(recordOrEmpty(ordered.providers.ollama), ["base_url", "model"]);
-  ordered.vector_store = orderObject(ordered.vector_store, [
-    "adapter",
-    "collection_name",
-    "qdrant",
-    "lancedb"
-  ]);
-  ordered.vector_store.qdrant = orderObject(recordOrEmpty(ordered.vector_store.qdrant), ["url", "api_key"]);
-  ordered.vector_store.lancedb = orderObject(recordOrEmpty(ordered.vector_store.lancedb), ["path"]);
-}
-function buildSerializeBaseSettings(settings) {
-  return {
-    ...settings,
-    locks: valueOrDefault(settings.locks, SETTINGS_DEFAULTS.locks),
-    checkpoints: valueOrDefault(settings.checkpoints, SETTINGS_DEFAULTS.checkpoints),
-    output: valueOrDefault(settings.output, SETTINGS_DEFAULTS.output),
-    history: valueOrDefault(settings.history, SETTINGS_DEFAULTS.history),
-    validation: valueOrDefault(settings.validation, SETTINGS_DEFAULTS.validation),
-    workflow: valueOrDefault(settings.workflow, SETTINGS_DEFAULTS.workflow),
-    testing: valueOrDefault(settings.testing, SETTINGS_DEFAULTS.testing),
-    telemetry: valueOrDefault(settings.telemetry, SETTINGS_DEFAULTS.telemetry),
-    agent_guidance: valueOrDefault(settings.agent_guidance, SETTINGS_DEFAULTS.agent_guidance),
-    item_types: valueOrDefault(settings.item_types, SETTINGS_DEFAULTS.item_types),
-    schema: valueOrDefault(settings.schema, SETTINGS_DEFAULTS.schema),
-    context: valueOrDefault(settings.context, SETTINGS_DEFAULTS.context),
-    extensions: valueOrDefault(settings.extensions, SETTINGS_DEFAULTS.extensions),
-    search: valueOrDefault(settings.search, SETTINGS_DEFAULTS.search),
-    providers: valueOrDefault(settings.providers, SETTINGS_DEFAULTS.providers),
-    vector_store: valueOrDefault(settings.vector_store, SETTINGS_DEFAULTS.vector_store)
-  };
-}
-function buildSerializedValidationSettings(baseSettings, governance) {
-  return {
-    ...baseSettings.validation,
-    parent_reference: governance.parent_reference,
-    metadata_profile: governance.metadata_profile,
-    metadata_required_fields: normalizeValidationMetadataRequiredFields(baseSettings.validation?.metadata_required_fields),
-    lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_stale_blocker_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_stale_blocker_reason_patterns),
-    lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_blocked_reason_patterns),
-    lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_resolution_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_resolution_patterns),
-    lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_actual_result_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_actual_result_patterns),
-    estimate_defaults_by_type: normalizeEstimateDefaultOverrides(baseSettings.validation?.estimate_defaults_by_type)
-  };
-}
-function buildSerializedSearchSettings(baseSettings) {
-  return {
-    ...SETTINGS_DEFAULTS.search,
-    ...baseSettings.search,
-    mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(baseSettings.search?.mutation_refresh_policy),
-    query_expansion: {
-      ...SETTINGS_DEFAULTS.search.query_expansion,
-      ...baseSettings.search?.query_expansion,
-      enabled: normalizeSearchQueryExpansionEnabled(baseSettings.search?.query_expansion?.enabled),
-      provider: normalizeSearchQueryExpansionProvider(baseSettings.search?.query_expansion?.provider)
-    },
-    rerank: {
-      ...SETTINGS_DEFAULTS.search.rerank,
-      ...baseSettings.search?.rerank,
-      enabled: normalizeSearchRerankEnabled(baseSettings.search?.rerank?.enabled),
-      model: normalizeSearchRerankModel(baseSettings.search?.rerank?.model),
-      top_k: normalizeSearchRerankTopK(baseSettings.search?.rerank?.top_k)
-    }
-  };
-}
-function buildSerializedContextSettings(baseSettings) {
-  return {
-    default_depth: baseSettings.context?.default_depth ?? SETTINGS_DEFAULTS.context.default_depth,
-    activity_limit: baseSettings.context?.activity_limit ?? SETTINGS_DEFAULTS.context.activity_limit,
-    stale_threshold_days: baseSettings.context?.stale_threshold_days ?? SETTINGS_DEFAULTS.context.stale_threshold_days,
-    sections: {
-      ...SETTINGS_DEFAULTS.context.sections,
-      ...baseSettings.context?.sections
-    }
-  };
-}
-function buildSerializedVectorStoreSettings(baseSettings) {
-  return {
-    ...baseSettings.vector_store,
-    adapter: baseSettings.vector_store?.adapter ?? SETTINGS_DEFAULTS.vector_store.adapter,
-    collection_name: normalizeVectorStoreCollectionName(baseSettings.vector_store?.collection_name),
-    qdrant: { ...baseSettings.vector_store?.qdrant },
-    lancedb: { ...baseSettings.vector_store?.lancedb }
-  };
-}
-function buildNormalizedSettingsForSerialization(baseSettings, governance, normalizedSchema, persistedFileBackedSections) {
-  return {
-    ...baseSettings,
-    item_format: "toon",
-    validation: buildSerializedValidationSettings(baseSettings, governance),
-    governance,
-    agent_guidance: normalizeAgentGuidanceSettings(baseSettings.agent_guidance),
-    item_types: {
-      definitions: persistedFileBackedSections.item_type_definitions
-    },
-    schema: {
-      ...normalizedSchema,
-      statuses: persistedFileBackedSections.schema_statuses,
-      fields: persistedFileBackedSections.schema_fields,
-      type_workflows: persistedFileBackedSections.schema_type_workflows
-    },
-    search: buildSerializedSearchSettings(baseSettings),
-    context: buildSerializedContextSettings(baseSettings),
-    extensions: {
-      enabled: normalizeStringList2(baseSettings.extensions?.enabled),
-      disabled: normalizeStringList2(baseSettings.extensions?.disabled),
-      policy: normalizeExtensionPolicySettings(baseSettings.extensions?.policy)
-    },
-    vector_store: buildSerializedVectorStoreSettings(baseSettings)
-  };
-}
-function serializeSettings(settings, options = {}) {
-  const baseSettings = buildSerializeBaseSettings(settings);
-  const governance = resolveGovernanceKnobs(baseSettings);
-  const normalizedSchema = normalizeRuntimeSchemaSettings(baseSettings.schema);
-  const persistedFileBackedSections = resolvePersistedFileBackedSchemaSections(baseSettings, options.persist_source);
-  const normalizedSettings = buildNormalizedSettingsForSerialization(baseSettings, governance, normalizedSchema, persistedFileBackedSections);
-  const ordered = orderObject({
-    ...normalizedSettings,
-    governance: normalizeGovernanceForPersist(governance)
-  }, [
-    "version",
-    "id_prefix",
-    "author_default",
-    "item_format",
-    "locks",
-    "checkpoints",
-    "output",
-    "history",
-    "validation",
-    "governance",
-    "workflow",
-    "testing",
-    "telemetry",
-    "agent_guidance",
-    "item_types",
-    "schema",
-    "context",
-    "extensions",
-    "search",
-    "providers",
-    "vector_store"
-  ]);
-  orderSerializedSettingsSections(ordered);
-  return `${JSON.stringify(ordered, null, 2)}
-`;
-}
-async function readSettingsWithMetadata(pmRoot) {
-  const settingsPath = getSettingsPath(pmRoot);
-  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 {
-    const fallback = buildFallbackSettingsReadResult("settings_read_invalid_json");
-    await cacheSettingsReadResultIfStable(pmRoot, [settingsPath], fallback, settingsSignaturesAfterRead, [settingsPath]);
-    return fallback;
-  }
-  const validated = validateSettings(parsed);
-  if (!validated.success) {
-    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: {
-        definitions: normalizeItemTypeDefinitions([
-          ...mergedSettings.item_types.definitions,
-          ...arrayOrEmpty(loadedSchemaSections.type_definitions_from_file)
-        ])
-      },
-      schema: loadedSchemaSections.schema
-    };
-    attachSettingsPersistSourceSnapshot(settings, buildSettingsPersistSourceSnapshot(validated.data, settings));
-    const result = {
-      settings,
-      metadata: {
-        has_explicit_item_format: hasExplicitItemFormat(parsed)
-      },
-      warnings: [
-        ...validated.data.item_format === "json_markdown" ? ["settings_item_format_legacy_json_markdown_coerced_to_toon"] : [],
-        ...schemaScaffold.created_paths.map((createdPath) => `runtime_schema_bootstrap_created:${createdPath}`),
-        ...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 {
-    const fallback = buildFallbackSettingsReadResult("settings_read_merge_failed");
-    await cacheSettingsReadResultSafe(pmRoot, trackedPathsForFailure, fallback);
-    return fallback;
-  }
-}
-async function readSettings(pmRoot) {
-  return (await readSettingsWithMetadata(pmRoot)).settings;
-}
-async function writeSettings(pmRoot, settings, op = SETTINGS_WRITE_OP) {
-  const settingsPath = getSettingsPath(pmRoot);
-  await writeFileAtomic(settingsPath, serializeSettings(settings, {
-    persist_source: getSettingsPersistSourceSnapshot(settings)
-  }));
-  try {
-    await runActiveOnWriteHooks({
-      path: settingsPath,
-      scope: "project",
-      op
-    });
-  } finally {
-    clearSettingsReadCache(pmRoot);
-  }
-}
-
 export {
   ensureDir,
   pathExists,
@@ -7240,13 +5491,17 @@ export {
   isPathWithinDirectory,
   resolvePmPackageRootFromModule,
   resolvePmCliVersion,
+  resolveConfiguredPmPackageRoot,
   KNOWN_EXTENSION_CAPABILITIES,
+  EXTENSION_CAPABILITY_CONTRACT_VERSION,
+  EXTENSION_CAPABILITY_LEGACY_ALIASES,
   EXTENSION_CAPABILITY_CONTRACT,
   KNOWN_EXTENSION_POLICY_MODES,
   KNOWN_EXTENSION_TRUST_MODES,
   KNOWN_EXTENSION_SANDBOX_PROFILES,
   KNOWN_EXTENSION_POLICY_SURFACES,
   KNOWN_EXTENSION_SERVICE_NAMES,
+  createDefaultExtensionGovernancePolicy,
   PM_DIRNAME,
   CREATE_DIRECT_CLOSE_REASON_DEFAULT,
   PM_CORE_REQUIRED_SUBDIRS,
@@ -7262,15 +5517,18 @@ export {
   EXIT_CODE,
   resolveTelemetryErrorCategory,
   BUILTIN_ITEM_TYPE_VALUES,
+  ITEM_TYPE_VALUES,
   STATUS_VALUES,
   RUNTIME_STATUS_ROLE_VALUES,
   RUNTIME_FIELD_TYPE_VALUES,
   RUNTIME_FIELD_COMMAND_VALUES,
+  RUNTIME_UNKNOWN_FIELD_POLICY_VALUES,
   DEPENDENCY_KIND_VALUES,
   SCOPE_VALUES,
   RISK_VALUES,
   ISSUE_SEVERITY_VALUES,
   CONFIDENCE_TEXT_VALUES,
+  GOVERNANCE_PRESET_VALUES,
   RECURRENCE_FREQUENCY_VALUES,
   RECURRENCE_WEEKDAY_VALUES,
   weekdayOrderIndex,
@@ -7280,6 +5538,7 @@ export {
   PLAN_STEP_LINK_KIND_VALUES,
   CONTEXT_DEPTH_VALUES,
   CONTEXT_SECTION_VALUES,
+  normalizeItemTypeDefinition,
   COMMON_MUTATION_COMMAND_OPTION_KEYS,
   canonicalizeCommandOptionKey,
   commandOptionFlagLabel,
@@ -7315,71 +5574,57 @@ export {
   coercePositiveInteger,
   coerceNumberInRange,
   asRecordOrNull,
+  asPropertyRecord,
+  resolveActivatablePropertyRecord,
   resolveFlagValueKind,
   flattenFlagListValue,
   levenshteinDistanceWithinLimit,
   normalizeItemFieldType,
+  evaluatePmMinVersionBound,
+  evaluatePmMaxVersionBound,
+  normalizeKnownExtensionCapability,
+  resolveLegacyExtensionCapabilityAlias,
   parseUnknownExtensionCapabilityWarning,
   parseLegacyExtensionCapabilityAliasWarning,
+  normalizeCommandName,
   createEmptyExtensionRegistrationRegistry,
   runBeforeCommandHooks,
   runAfterCommandHooks,
+  runOnWriteHooks,
+  runOnReadHooks,
+  runOnIndexHooks,
+  runCommandHandler,
+  runParserOverride,
+  runPreflightOverride,
+  runServiceOverrideSync,
+  runServiceOverride,
+  runCommandOverride,
+  runRendererOverride,
+  DEFAULT_EXTENSION_PRIORITY,
   nextExtensionReloadToken,
+  isCanonicalPathWithinDirectory,
   resolveExtensionRoots,
   discoverExtensions,
   loadExtensions,
+  deactivateExtensions,
   activateExtensions,
+  EXTENSION_CAPABILITY_REGISTRATION_SURFACES,
   normalizeExtensionName,
   collectUsedExtensionCapabilities,
   reconcileExtensionCapabilityUsage,
-  setActiveExtensionHooks,
-  setActiveExtensionCommands,
-  setActiveExtensionParsers,
-  setActiveExtensionPreflight,
-  setActiveExtensionServices,
-  setActiveExtensionRenderers,
-  setActiveExtensionRegistrations,
-  getActiveExtensionRegistrations,
-  setActiveCommandContext,
-  setActiveCommandResult,
-  getActiveCommandResult,
-  recordAfterCommandAffectedItem,
-  projectAfterCommandItemSnapshot,
-  consumeAfterCommandAffectedItems,
-  clearActiveExtensionHooks,
-  runActiveOnWriteHooks,
-  runActiveOnReadHooks,
-  hasActiveOnReadHooks,
-  runActiveOnIndexHooks,
-  runActiveCommandOverride,
-  runActiveCommandHandler,
-  runActiveParserOverride,
-  runActivePreflightOverride,
-  runActiveRendererOverride,
-  runActiveServiceOverride,
-  runActiveServiceOverrideSync,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   DEFAULT_RUNTIME_STATUS_DEFINITIONS,
   normalizeRuntimeSchemaSettings,
   filePathForSchemaSection,
   resolveItemTypesFilePath,
   ensureRuntimeSchemaFileScaffold,
+  loadRuntimeSchemaFromOptionalFiles,
   resolveRuntimeStatusRegistry,
   normalizeStatusInputWithRegistry,
   resolveRuntimeFieldRegistry,
   runtimeFieldOptionTarget,
-  statusIsTerminal,
-  PmCliError,
-  stableStringify,
-  stableValueEquals,
-  sha256Hex,
-  orderObject,
-  resolveEstimateDefaultMinutes,
-  resolveGovernanceKnobs,
-  readSettingsWithMetadata,
-  readSettings,
-  writeSettings
+  statusIsTerminal
 };
-//# sourceMappingURL=chunk-SL2ANJSV.js.map
+//# sourceMappingURL=chunk-YD5FML7K.js.map
 
-//# debugId=59f1e772-921a-51db-980b-56d08f636039
+//# debugId=b82b3892-108d-51df-a033-47913481d9b1