@unbrained/pm-cli 2026.5.31 → 2026.6.6

package/dist/cli-bundle/chunks/{chunk-LSXGH6NE.js → chunk-U5SXYXSY.js}

@@ -78,11 +78,54 @@ function isPathWithinDirectory(directory, targetPath) {
   return !relative.startsWith("..") && !path2.isAbsolute(relative);
 }
 
+// dist/core/packages/root.js
+import fs2 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+!(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] = "20b7827b-6f96-518c-8df3-b699d41dec88");
+  } catch (e2) {
+  }
+})();
+var PM_CLI_PACKAGE_NAME = "@unbrained/pm-cli";
+function packageJsonNamesPmCli(packageJsonPath) {
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    return parsed.name === PM_CLI_PACKAGE_NAME;
+  } catch {
+    return false;
+  }
+}
+function findPmPackageRootFromPath(startPath) {
+  let current = fs2.existsSync(startPath) && fs2.statSync(startPath).isDirectory() ? path3.resolve(startPath) : path3.dirname(path3.resolve(startPath));
+  while (true) {
+    const packageJsonPath = path3.join(current, "package.json");
+    if (fs2.existsSync(packageJsonPath) && packageJsonNamesPmCli(packageJsonPath)) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function resolvePmPackageRootFromModule(metaUrl, fallbackRelativeSegments = []) {
+  const modulePath = fileURLToPath(metaUrl);
+  const discovered = findPmPackageRootFromPath(modulePath);
+  if (discovered) {
+    return discovered;
+  }
+  return path3.resolve(path3.dirname(modulePath), ...fallbackRelativeSegments);
+}
+
 // dist/core/extensions/extension-types.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] = "75f1bede-2849-550d-8e31-0492def7d786");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "80b2d723-e806-55be-a67f-bdb9fa8ad3ed");
   } catch (e2) {
   }
 })();
@@ -541,7 +584,7 @@ function resolveTelemetryErrorCategory(errorCode) {
 // dist/core/store/paths.js
 import { statSync } from "node:fs";
 import os from "node:os";
-import path3 from "node:path";
+import path4 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
@@ -567,14 +610,14 @@ function pathExists2(pathValue) {
   }
 }
 function discoverPmRootFromAncestors(cwd) {
-  let current = path3.resolve(cwd);
+  let current = path4.resolve(cwd);
   while (true) {
-    const candidateRoot = path3.join(current, PM_DIRNAME);
-    const candidateSettingsPath = path3.join(candidateRoot, SETTINGS_FILENAME);
+    const candidateRoot = path4.join(current, PM_DIRNAME);
+    const candidateSettingsPath = path4.join(candidateRoot, SETTINGS_FILENAME);
     if (pathExists2(candidateSettingsPath)) {
       return candidateRoot;
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -585,22 +628,22 @@ function resolvePmRoot(cwd, cliPath) {
   const envPath = process.env.PM_PATH;
   const explicitPath = cliPath?.trim() || envPath?.trim();
   if (explicitPath) {
-    return path3.resolve(cwd, explicitPath);
+    return path4.resolve(cwd, explicitPath);
   }
   const discoveredRoot = discoverPmRootFromAncestors(cwd);
   if (discoveredRoot) {
     return discoveredRoot;
   }
   const selected = PM_DIRNAME;
-  return path3.resolve(cwd, selected);
+  return path4.resolve(cwd, selected);
 }
 function resolveGlobalPmRoot(cwd) {
   const envPath = process.env.PM_GLOBAL_PATH?.trim();
-  const selected = envPath && envPath.length > 0 ? envPath : path3.join(os.homedir(), ".pm-cli");
-  return path3.resolve(cwd, selected);
+  const selected = envPath && envPath.length > 0 ? envPath : path4.join(os.homedir(), ".pm-cli");
+  return path4.resolve(cwd, selected);
 }
 function getSettingsPath(pmRoot) {
-  return path3.join(pmRoot, SETTINGS_FILENAME);
+  return path4.join(pmRoot, SETTINGS_FILENAME);
 }
 function deriveDefaultTypeFolder(type) {
   const normalized = type.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -611,50 +654,50 @@ function deriveDefaultTypeFolder(type) {
 }
 function getTypeDirPath(pmRoot, type, typeToFolder = TYPE_TO_FOLDER) {
   const folder = typeToFolder[type] ?? deriveDefaultTypeFolder(type);
-  return path3.join(pmRoot, folder);
+  return path4.join(pmRoot, folder);
 }
 function getItemPath(pmRoot, type, id, itemFormat = "toon", typeToFolder = TYPE_TO_FOLDER) {
-  return path3.join(getTypeDirPath(pmRoot, type, typeToFolder), `${id}${ITEM_FILE_EXTENSION_BY_FORMAT[itemFormat]}`);
+  return path4.join(getTypeDirPath(pmRoot, type, typeToFolder), `${id}${ITEM_FILE_EXTENSION_BY_FORMAT[itemFormat]}`);
 }
 function getItemFormatFromPath(itemPath) {
-  const extension = path3.extname(itemPath).toLowerCase();
+  const extension = path4.extname(itemPath).toLowerCase();
   return ITEM_FORMAT_BY_EXTENSION[extension] ?? null;
 }
 function getHistoryPath(pmRoot, id) {
-  return path3.join(pmRoot, "history", `${id}.jsonl`);
+  return path4.join(pmRoot, "history", `${id}.jsonl`);
 }
 function getLockPath(pmRoot, id) {
-  return path3.join(pmRoot, "locks", `${id}.lock`);
+  return path4.join(pmRoot, "locks", `${id}.lock`);
 }
 function getRuntimePath(pmRoot) {
-  return path3.join(pmRoot, "runtime");
+  return path4.join(pmRoot, "runtime");
 }
 function getTestRunsPath(pmRoot) {
-  return path3.join(getRuntimePath(pmRoot), "test-runs");
+  return path4.join(getRuntimePath(pmRoot), "test-runs");
 }
 function getTestRunsRecordsPath(pmRoot) {
-  return path3.join(getTestRunsPath(pmRoot), "runs");
+  return path4.join(getTestRunsPath(pmRoot), "runs");
 }
 function getTestRunRecordPath(pmRoot, runId) {
-  return path3.join(getTestRunsRecordsPath(pmRoot), `${runId}.json`);
+  return path4.join(getTestRunsRecordsPath(pmRoot), `${runId}.json`);
 }
 function getTestRunsStdoutPath(pmRoot) {
-  return path3.join(getTestRunsPath(pmRoot), "stdout");
+  return path4.join(getTestRunsPath(pmRoot), "stdout");
 }
 function getTestRunsStderrPath(pmRoot) {
-  return path3.join(getTestRunsPath(pmRoot), "stderr");
+  return path4.join(getTestRunsPath(pmRoot), "stderr");
 }
 function getTestRunStdoutPath(pmRoot, runId) {
-  return path3.join(getTestRunsStdoutPath(pmRoot), `${runId}.log`);
+  return path4.join(getTestRunsStdoutPath(pmRoot), `${runId}.log`);
 }
 function getTestRunStderrPath(pmRoot, runId) {
-  return path3.join(getTestRunsStderrPath(pmRoot), `${runId}.log`);
+  return path4.join(getTestRunsStderrPath(pmRoot), `${runId}.log`);
 }
 function getTestRunsResultsPath(pmRoot) {
-  return path3.join(getTestRunsPath(pmRoot), "results");
+  return path4.join(getTestRunsPath(pmRoot), "results");
 }
 function getTestRunResultPath(pmRoot, runId) {
-  return path3.join(getTestRunsResultsPath(pmRoot), `${runId}.json`);
+  return path4.join(getTestRunsResultsPath(pmRoot), `${runId}.json`);
 }
 
 // dist/core/shared/primitives.js
@@ -858,6 +901,63 @@ function parseLegacyExtensionCapabilityAliasWarning(warning) {
   return parsed;
 }
 
+// dist/core/extensions/extension-registries.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] = "8789ac45-d04d-5d1b-984a-cf5159fc01ba");
+  } catch (e2) {
+  }
+})();
+function createEmptyExtensionHookRegistry() {
+  return {
+    beforeCommand: [],
+    afterCommand: [],
+    onWrite: [],
+    onRead: [],
+    onIndex: []
+  };
+}
+function createEmptyExtensionCommandRegistry() {
+  return {
+    overrides: [],
+    handlers: []
+  };
+}
+function createEmptyExtensionParserRegistry() {
+  return {
+    overrides: []
+  };
+}
+function createEmptyExtensionPreflightRegistry() {
+  return {
+    overrides: []
+  };
+}
+function createEmptyExtensionServiceRegistry() {
+  return {
+    overrides: []
+  };
+}
+function createEmptyExtensionRendererRegistry() {
+  return {
+    overrides: []
+  };
+}
+function createEmptyExtensionRegistrationRegistry() {
+  return {
+    commands: [],
+    flags: [],
+    item_fields: [],
+    item_types: [],
+    migrations: [],
+    importers: [],
+    exporters: [],
+    search_providers: [],
+    vector_store_adapters: []
+  };
+}
+
 // dist/core/extensions/extension-runtime-helpers.js
 !(function() {
   try {
@@ -891,7 +991,7 @@ function cloneContextSnapshot(value) {
 !(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] = "015da859-473a-5b98-b534-a4edbfae0dd7");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0911739b-401c-5c7a-9073-c44e67d1bc39");
   } catch (e2) {
   }
 })();
@@ -1255,6 +1355,13 @@ function runRendererOverride(renderers, context) {
       pm_root: rendererPmRoot,
       result: cloneContextSnapshot(context.result)
     });
+    if (rendered === null || rendered === void 0) {
+      return {
+        overridden: false,
+        rendered: null,
+        warnings: []
+      };
+    }
     if (typeof rendered !== "string") {
       return {
         overridden: false,
@@ -1277,8 +1384,8 @@ function runRendererOverride(renderers, context) {
 }
 
 // dist/core/extensions/loader.js
-import fs2 from "node:fs/promises";
-import path4 from "node:path";
+import fs3 from "node:fs/promises";
+import path5 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // dist/core/extensions/extension-policy.js
@@ -1750,78 +1857,53 @@ function evaluateExtensionPolicyForRegistration(policy, extension, surface, meth
   };
 }
 
-// dist/core/extensions/extension-registries.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] = "8789ac45-d04d-5d1b-984a-cf5159fc01ba");
-  } catch (e2) {
-  }
-})();
-function createEmptyExtensionHookRegistry() {
-  return {
-    beforeCommand: [],
-    afterCommand: [],
-    onWrite: [],
-    onRead: [],
-    onIndex: []
-  };
-}
-function createEmptyExtensionCommandRegistry() {
-  return {
-    overrides: [],
-    handlers: []
-  };
-}
-function createEmptyExtensionParserRegistry() {
-  return {
-    overrides: []
-  };
-}
-function createEmptyExtensionPreflightRegistry() {
-  return {
-    overrides: []
-  };
-}
-function createEmptyExtensionServiceRegistry() {
-  return {
-    overrides: []
-  };
-}
-function createEmptyExtensionRendererRegistry() {
-  return {
-    overrides: []
-  };
-}
-function createEmptyExtensionRegistrationRegistry() {
-  return {
-    commands: [],
-    flags: [],
-    item_fields: [],
-    item_types: [],
-    migrations: [],
-    importers: [],
-    exporters: [],
-    search_providers: [],
-    vector_store_adapters: []
-  };
-}
-
 // dist/core/extensions/loader.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] = "4fba8687-0797-5479-afc8-12f1a2e5a954");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "c1d2f70f-a61e-585b-bfee-5401b41545f8");
   } catch (e2) {
   }
 })();
 var DEFAULT_EXTENSION_PRIORITY = 100;
+var currentPmCliVersionPromise = null;
 var DEFAULT_EXTENSION_POLICY = Object.freeze(createDefaultExtensionGovernancePolicy());
 var extensionReloadEpoch = 0;
 function nextExtensionReloadToken(seed = Date.now()) {
   extensionReloadEpoch += 1;
   return `${extensionReloadEpoch}-${seed}`;
 }
+function parseOptionalManifestString(candidate, field) {
+  const value = candidate[field];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return null;
+  }
+  return value.trim();
+}
+function parseManifestEngines(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const enginesRecord = asRecordLoose(value);
+  if (!enginesRecord) {
+    return null;
+  }
+  const engines = {};
+  for (const key of Object.keys(enginesRecord).sort((left, right) => left.localeCompare(right))) {
+    if (key.trim().length === 0) {
+      return null;
+    }
+    const engineValue = enginesRecord[key];
+    if (typeof engineValue !== "string" || engineValue.trim().length === 0) {
+      return null;
+    }
+    engines[key.trim()] = engineValue.trim();
+  }
+  return Object.keys(engines).length > 0 ? engines : void 0;
+}
 function parseManifest(raw) {
   if (typeof raw !== "object" || raw === null) {
     return null;
@@ -1850,6 +1932,18 @@ function parseManifest(raw) {
     }
     manifestVersion = candidate.manifest_version;
   }
+  const pmMinVersion = parseOptionalManifestString(candidate, "pm_min_version");
+  if (pmMinVersion === null) {
+    return null;
+  }
+  const pmMaxVersion = parseOptionalManifestString(candidate, "pm_max_version");
+  if (pmMaxVersion === null) {
+    return null;
+  }
+  const engines = parseManifestEngines(candidate.engines);
+  if (engines === null) {
+    return null;
+  }
   let trusted;
   if ("trusted" in candidate && candidate.trusted !== void 0 && candidate.trusted !== null) {
     if (typeof candidate.trusted !== "boolean") {
@@ -1931,16 +2025,41 @@ function parseManifest(raw) {
     capabilities = normalizedCapabilities.capabilities;
     legacyCapabilityAliases = normalizedCapabilities.legacy_aliases;
   }
+  let activation;
+  if ("activation" in candidate && candidate.activation !== void 0 && candidate.activation !== null) {
+    const activationRecord = asRecordLoose(candidate.activation);
+    if (!activationRecord) {
+      return null;
+    }
+    const rawCommands = activationRecord.commands;
+    if (rawCommands !== void 0 && rawCommands !== null) {
+      if (!Array.isArray(rawCommands) || rawCommands.some((value) => typeof value !== "string")) {
+        return null;
+      }
+      const commands = [
+        ...new Set(rawCommands.map((value) => normalizeCommandName(value)).filter((value) => value.length > 0))
+      ].sort((left, right) => left.localeCompare(right));
+      if (commands.length > 0) {
+        activation = {
+          commands
+        };
+      }
+    }
+  }
   return {
     name: candidate.name.trim(),
     version: candidate.version.trim(),
     entry: candidate.entry.trim(),
     priority,
     manifest_version: manifestVersion,
+    pm_min_version: pmMinVersion,
+    pm_max_version: pmMaxVersion,
+    engines,
     trusted,
     provenance,
     sandbox_profile: sandboxProfile,
     permissions,
+    activation,
     capabilities,
     legacy_capability_aliases: legacyCapabilityAliases.length > 0 ? legacyCapabilityAliases : void 0
   };
@@ -1955,18 +2074,18 @@ function shouldEnable(name, enabled, disabled) {
   return enabled.has(name);
 }
 async function isCanonicalPathWithinDirectory(directory, targetPath) {
-  const [resolvedDirectory, resolvedTargetPath] = await Promise.all([fs2.realpath(directory), fs2.realpath(targetPath)]);
+  const [resolvedDirectory, resolvedTargetPath] = await Promise.all([fs3.realpath(directory), fs3.realpath(targetPath)]);
   return isPathWithinDirectory(resolvedDirectory, resolvedTargetPath);
 }
 function resolveExtensionRoots(pmRoot, cwd = process.cwd()) {
   return {
-    global: path4.join(resolveGlobalPmRoot(cwd), "extensions"),
-    project: path4.join(pmRoot, "extensions")
+    global: path5.join(resolveGlobalPmRoot(cwd), "extensions"),
+    project: path5.join(pmRoot, "extensions")
   };
 }
 async function listExtensionDirectories(extensionsRoot) {
   try {
-    const entries = await fs2.readdir(extensionsRoot, { withFileTypes: true });
+    const entries = await fs3.readdir(extensionsRoot, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   } catch {
     return [];
@@ -1983,11 +2102,17 @@ function summarizeCandidate(candidate) {
     priority: candidate.manifest.priority,
     entry_path: candidate.entry_path,
     manifest_version: candidate.manifest.manifest_version,
+    pm_min_version: candidate.manifest.pm_min_version,
+    pm_max_version: candidate.manifest.pm_max_version,
+    engines: candidate.manifest.engines,
     trusted: candidate.manifest.trusted,
     provenance: candidate.manifest.provenance,
     sandbox_profile: candidate.manifest.sandbox_profile,
     permissions: candidate.manifest.permissions,
-    capabilities: [...candidate.manifest.capabilities]
+    capabilities: [...candidate.manifest.capabilities],
+    activation: candidate.manifest.activation ? {
+      commands: [...candidate.manifest.activation.commands ?? []]
+    } : void 0
   };
 }
 function sortCandidates(candidates) {
@@ -2030,8 +2155,8 @@ async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled) {
   return { diagnostics, warnings, candidates };
 }
 async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled) {
-  const extensionDir = path4.join(extensionsRoot, directory);
-  const manifestPath = path4.join(extensionDir, "manifest.json");
+  const extensionDir = path5.join(extensionsRoot, directory);
+  const manifestPath = path5.join(extensionDir, "manifest.json");
   if (!await pathExists(manifestPath)) {
     return {
       diagnostic: {
@@ -2052,7 +2177,7 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
   }
   let manifest = null;
   try {
-    const parsed = JSON.parse(await fs2.readFile(manifestPath, "utf8"));
+    const parsed = JSON.parse(await fs3.readFile(manifestPath, "utf8"));
     manifest = parseManifest(parsed);
   } catch {
     manifest = null;
@@ -2075,7 +2200,7 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
       candidate: null
     };
   }
-  const entryPath = path4.resolve(extensionDir, manifest.entry);
+  const entryPath = path5.resolve(extensionDir, manifest.entry);
   const entryWithinDirectoryByPath = isPathWithinDirectory(extensionDir, entryPath);
   const entryExists = entryWithinDirectoryByPath ? await pathExists(entryPath) : false;
   const entryWithinDirectory = entryWithinDirectoryByPath && entryExists ? await isCanonicalPathWithinDirectory(extensionDir, entryPath) : entryWithinDirectoryByPath;
@@ -2092,6 +2217,15 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
   } else if (!entryExists) {
     extensionWarnings.push(`extension_entry_missing:${layer}:${manifest.name}`);
   }
+  const pmVersionCompatibility = await evaluatePmMinVersionCompatibility(layer, manifest);
+  if (pmVersionCompatibility.warning) {
+    extensionWarnings.push(pmVersionCompatibility.warning);
+  }
+  const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest);
+  if (pmMaxVersionCompatibility.warning) {
+    extensionWarnings.push(pmMaxVersionCompatibility.warning);
+  }
+  const extensionReady = entryWithinDirectory && entryExists && pmVersionCompatibility.allowed && pmMaxVersionCompatibility.allowed;
   return {
     diagnostic: {
       layer,
@@ -2103,10 +2237,10 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
       priority: manifest.priority,
       entry_path: entryPath,
       enabled: enabledForLoad,
-      status: entryWithinDirectory && entryExists ? "ok" : "warn"
+      status: extensionReady ? "ok" : "warn"
     },
     warnings: extensionWarnings,
-    candidate: entryWithinDirectory && entryExists && enabledForLoad ? {
+    candidate: extensionReady && enabledForLoad ? {
       layer,
       directory,
       manifest_path: manifestPath,
@@ -2188,9 +2322,120 @@ function formatUnknownError(error) {
   }
   return String(error);
 }
+function parseComparableVersion(value) {
+  const normalized = value.trim().replace(/^>=\s*/, "").replace(/^v/i, "");
+  const release = normalized.split(/[+-]/, 1)[0] ?? "";
+  if (!/^\d+(?:[.-]\d+)*$/.test(release)) {
+    return null;
+  }
+  return release.split(/[.-]/).map((part) => Number(part));
+}
+function compareComparableVersions(currentVersion, minimumVersion) {
+  const currentParts = parseComparableVersion(currentVersion);
+  const minimumParts = parseComparableVersion(minimumVersion);
+  if (!currentParts || !minimumParts) {
+    return null;
+  }
+  const width = Math.max(currentParts.length, minimumParts.length);
+  for (let index = 0; index < width; index += 1) {
+    const current = currentParts[index] ?? 0;
+    const minimum = minimumParts[index] ?? 0;
+    if (current > minimum) {
+      return 1;
+    }
+    if (current < minimum) {
+      return -1;
+    }
+  }
+  return 0;
+}
+async function readCurrentPmCliVersion() {
+  try {
+    const packageRoot = resolvePmPackageRootFromModule(import.meta.url, ["../../.."]);
+    const raw = await fs3.readFile(path5.join(packageRoot, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function resolveCurrentPmCliVersion() {
+  currentPmCliVersionPromise ??= readCurrentPmCliVersion();
+  return currentPmCliVersionPromise;
+}
+async function evaluatePmMinVersionCompatibility(layer, manifest) {
+  if (typeof manifest.pm_min_version !== "string" || manifest.pm_min_version.trim().length === 0) {
+    return { allowed: true };
+  }
+  if (!parseComparableVersion(manifest.pm_min_version)) {
+    return {
+      allowed: false,
+      warning: `extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${manifest.pm_min_version}`
+    };
+  }
+  const currentVersion = await resolveCurrentPmCliVersion();
+  if (!currentVersion) {
+    return {
+      allowed: true,
+      warning: `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=unknown`
+    };
+  }
+  const comparison = compareComparableVersions(currentVersion, manifest.pm_min_version);
+  if (comparison === null) {
+    return {
+      allowed: true,
+      warning: `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=${currentVersion}`
+    };
+  }
+  if (comparison < 0) {
+    return {
+      allowed: false,
+      warning: `extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=${currentVersion}`
+    };
+  }
+  return { allowed: true };
+}
+async function evaluatePmMaxVersionCompatibility(layer, manifest) {
+  if (typeof manifest.pm_max_version !== "string" || manifest.pm_max_version.trim().length === 0) {
+    return { allowed: true };
+  }
+  if (/^[<>=~^]/.test(manifest.pm_max_version.trim())) {
+    return {
+      allowed: false,
+      warning: `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}`
+    };
+  }
+  if (!parseComparableVersion(manifest.pm_max_version)) {
+    return {
+      allowed: false,
+      warning: `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}`
+    };
+  }
+  const currentVersion = await resolveCurrentPmCliVersion();
+  if (!currentVersion) {
+    return {
+      allowed: true,
+      warning: `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=unknown`
+    };
+  }
+  const comparison = compareComparableVersions(currentVersion, manifest.pm_max_version);
+  if (comparison === null) {
+    return {
+      allowed: true,
+      warning: `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
+    };
+  }
+  if (comparison > 0) {
+    return {
+      allowed: false,
+      warning: `extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
+    };
+  }
+  return { allowed: true };
+}
 async function fingerprintPath(pathToInspect) {
   try {
-    const stats = await fs2.stat(pathToInspect);
+    const stats = await fs3.stat(pathToInspect);
     return `${Math.trunc(stats.mtimeMs)}-${stats.size}`;
   } catch {
     return "missing";
@@ -2599,7 +2844,15 @@ function assertExtensionCapability(extension, capability, method) {
     return;
   }
   if (!declared.has(capability)) {
-    throw new TypeError(`${method} requires capability '${capability}' in extension manifest capabilities`);
+    throw createRegistrationValidationError(`${method} requires capability '${capability}' in extension manifest capabilities`, {
+      method,
+      registration_index: -1,
+      capability,
+      missing_capability: capability,
+      expected_schema: `"capabilities": [..., "${capability}"]`,
+      received: extension.capabilities ?? [],
+      hint: `Add "${capability}" to ${extension.name} manifest capabilities, or remove the ${method} registration call.`
+    });
   }
 }
 function createExtensionApi(extension, hooks, commands, parsers, preflight, services, renderers, registrations, activationWarnings, policy) {
@@ -2854,7 +3107,52 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       definition: normalizeRegistrationRecord("registerMigration definition", definition)
     }, runtimeDefinition));
   };
-  const registerImporter = (name, importer) => {
+  const applyImportExportCommandMetadata = (method, commandPath, options) => {
+    if (options === void 0) {
+      return;
+    }
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+      throw new TypeError(`${method} options must be an object when provided`);
+    }
+    assertOptionalStringField(`${method} options.action`, options.action);
+    assertOptionalStringField(`${method} options.description`, options.description);
+    assertOptionalStringField(`${method} options.intent`, options.intent);
+    const action = resolveCommandDefinitionAction(commandPath, options.action);
+    const examples = normalizeOptionalStringArrayField(`${method} options.examples`, options.examples);
+    const failureHints = normalizeOptionalStringArrayField(`${method} options.failure_hints`, options.failure_hints);
+    const argumentsDefinition = normalizeCommandDefinitionArguments(options.arguments);
+    if (options.flags !== void 0) {
+      assertExtensionCapability(extension, "schema", `${method} options.flags`);
+      if (allowRegistration("schema.flags", `${method} options.flags`, "schema")) {
+        validateFlagDefinitions(options.flags);
+        registrations.flags.push({
+          layer: extension.layer,
+          name: extension.name,
+          target_command: commandPath,
+          flags: normalizeRegistrationRecordList(`${method} options.flags`, options.flags)
+        });
+      }
+    }
+    const registration = {
+      layer: extension.layer,
+      name: extension.name,
+      command: commandPath,
+      action,
+      examples,
+      failure_hints: failureHints,
+      arguments: argumentsDefinition
+    };
+    const description = options.description?.trim();
+    if (description) {
+      registration.description = description;
+    }
+    const intent = options.intent?.trim();
+    if (intent) {
+      registration.intent = intent;
+    }
+    registrations.commands.push(registration);
+  };
+  const registerImporter = (name, importer, options) => {
     assertExtensionCapability(extension, "importers", "registerImporter");
     if (!allowRegistration("importers.importer", "registerImporter", "importers")) {
       return;
@@ -2862,6 +3160,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerImporter name", name));
     assertFunctionHandler("registerImporter importer", importer);
     const commandPath = toRegistrationCommandPath(normalizedName, "import");
+    applyImportExportCommandMetadata("registerImporter", commandPath, options);
     registrations.importers.push({
       layer: extension.layer,
       name: extension.name,
@@ -2882,7 +3181,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       })
     });
   };
-  const registerExporter = (name, exporter) => {
+  const registerExporter = (name, exporter, options) => {
     assertExtensionCapability(extension, "importers", "registerExporter");
     if (!allowRegistration("importers.exporter", "registerExporter", "importers")) {
       return;
@@ -2890,6 +3189,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     const normalizedName = normalizeRegistrationName(assertNonEmptyString("registerExporter name", name));
     assertFunctionHandler("registerExporter exporter", exporter);
     const commandPath = toRegistrationCommandPath(normalizedName, "export");
+    applyImportExportCommandMetadata("registerExporter", commandPath, options);
     registrations.exporters.push({
       layer: extension.layer,
       name: extension.name,
@@ -3059,7 +3359,13 @@ function collectCommandCollisionWarnings(commands) {
   const handlerCommands = new Set(commands.handlers.map((entry) => entry.command));
   const overlapCommands = [...new Set(commands.overrides.map((entry) => entry.command))].filter((command) => handlerCommands.has(command)).sort((left, right) => left.localeCompare(right));
   for (const command of overlapCommands) {
-    warnings.push(`extension_command_override_handler_overlap:${command}`);
+    const handlers = commands.handlers.filter((entry) => entry.command === command);
+    const overrides = commands.overrides.filter((entry) => entry.command === command);
+    for (const override of overrides) {
+      for (const handler of handlers) {
+        warnings.push(`extension_command_override_handler_overlap:${command}:${override.layer}:${override.name}:${handler.layer}:${handler.name}`);
+      }
+    }
   }
   return warnings;
 }
@@ -3205,7 +3511,7 @@ async function activateExtensions(loadResult) {
 !(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] = "c826b268-5db1-567e-9a13-807ac5c092ff");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "81371981-f155-5140-ac02-37d83a4a4f81");
   } catch (e2) {
   }
 })();
@@ -3218,6 +3524,20 @@ 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;
 }
@@ -3251,6 +3571,47 @@ function setActiveCommandResult(result) {
 function getActiveCommandResult() {
   return activeCommandResult;
 }
+function recordAfterCommandAffectedItem(item) {
+  if (!item || (activeExtensionHooks?.afterCommand?.length ?? 0) === 0) {
+    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 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];
+    }
+  }
+  return snapshot;
+}
+function consumeAfterCommandAffectedItems() {
+  if (activeAfterCommandAffectedItems.length === 0) {
+    return void 0;
+  }
+  const affected = activeAfterCommandAffectedItems;
+  activeAfterCommandAffectedItems = [];
+  return affected;
+}
 function clearActiveExtensionHooks() {
   activeExtensionHooks = null;
   activeExtensionCommands = null;
@@ -3261,6 +3622,7 @@ function clearActiveExtensionHooks() {
   activeExtensionRegistrations = null;
   activeCommandContext = null;
   activeCommandResult = void 0;
+  activeAfterCommandAffectedItems = [];
 }
 async function runActiveOnWriteHooks(context) {
   if (!activeExtensionHooks) {
@@ -3397,7 +3759,7 @@ function runActiveServiceOverrideSync(service, payload) {
 !(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] = "d9b0e8e1-faef-5e56-a8a2-fd71d00a97ae");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "dd045bd8-53d3-51f9-8e24-1905c0ed6413");
   } catch (e2) {
   }
 })();
@@ -3513,11 +3875,11 @@ var CONTEXT_SECTION_VALUES = [
 })();
 
 // dist/core/schema/runtime-schema.js
-import path5 from "node:path";
+import path6 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f8b9437a-034b-5c44-917c-72eb805b32ac");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "11167959-e632-5d72-a6d1-103f6a7d50ef");
   } catch (e2) {
   }
 })();
@@ -3592,6 +3954,50 @@ function normalizeRuntimeWorkflow(workflow) {
     canceled_status: normalizeStatusId(workflow?.canceled_status)
   };
 }
+function normalizeTypeWorkflowDefinitions(workflows) {
+  if (!Array.isArray(workflows) || workflows.length === 0) {
+    return void 0;
+  }
+  const byTypeKey = /* @__PURE__ */ new Map();
+  for (const entry of workflows) {
+    const rawType = typeof entry?.type === "string" ? entry.type.trim() : "";
+    if (rawType.length === 0) {
+      continue;
+    }
+    if (!Array.isArray(entry?.allowed_transitions)) {
+      continue;
+    }
+    const typeKey = rawType.toLowerCase();
+    const pairs = entry.allowed_transitions;
+    const record = byTypeKey.get(typeKey) ?? { type: rawType, pairs: [], denyAll: false };
+    if (pairs.length === 0) {
+      record.denyAll = true;
+    }
+    for (const pair of pairs) {
+      if (!Array.isArray(pair) || pair.length !== 2) {
+        continue;
+      }
+      const from = normalizeStatusToken(pair[0]);
+      const to = normalizeStatusToken(pair[1]);
+      if (from.length === 0 || to.length === 0) {
+        continue;
+      }
+      if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
+        continue;
+      }
+      record.pairs.push([from, to]);
+    }
+    byTypeKey.set(typeKey, record);
+  }
+  const normalized = [];
+  for (const record of byTypeKey.values()) {
+    if (record.pairs.length > 0 || record.denyAll) {
+      normalized.push({ type: record.type, allowed_transitions: record.pairs });
+    }
+  }
+  normalized.sort((left, right) => left.type.localeCompare(right.type));
+  return normalized.length > 0 ? normalized : void 0;
+}
 function normalizeRuntimeFieldDefinition(definition) {
   const key = normalizeStatusToken(definition.key ?? "");
   if (!key) {
@@ -3691,6 +4097,7 @@ function normalizeRuntimeSchemaSettings(schema) {
       ...DEFAULT_RUNTIME_WORKFLOW,
       ...normalizeRuntimeWorkflow(schema?.workflow)
     },
+    type_workflows: normalizeTypeWorkflowDefinitions(schema?.type_workflows),
     unknown_field_policy: unknownFieldPolicy
   };
 }
@@ -3790,12 +4197,22 @@ function readWorkflowFromSchemaFile(parsed) {
   }
   return record;
 }
+function readTypeWorkflowsFromSchemaFile(parsed) {
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return void 0;
+  }
+  const record = parsed;
+  if (Array.isArray(record.type_workflows)) {
+    return record.type_workflows;
+  }
+  return void 0;
+}
 function filePathForSchemaSection(pmRoot, configuredPath, fallbackPath) {
   const normalized = configuredPath?.trim() || fallbackPath;
-  if (path5.isAbsolute(normalized)) {
+  if (path6.isAbsolute(normalized)) {
     return normalized;
   }
-  return path5.join(pmRoot, normalized);
+  return path6.join(pmRoot, normalized);
 }
 async function ensureRuntimeSchemaFileScaffold(pmRoot, schema) {
   const normalizedSchema = normalizeRuntimeSchemaSettings(schema);
@@ -3843,6 +4260,7 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
   let loadedStatuses;
   let loadedFields;
   let loadedWorkflow;
+  let loadedTypeWorkflows;
   const readAndParse = async (targetPath, warningKey) => {
     const raw = await readFileIfExists(targetPath);
     if (raw === null) {
@@ -3877,6 +4295,7 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
     if (loadedWorkflow === void 0) {
       warnings.push("runtime_schema_workflows_invalid_shape");
     }
+    loadedTypeWorkflows = readTypeWorkflowsFromSchemaFile(parsedWorkflow);
   }
   const mergedSchema = normalizeRuntimeSchemaSettings({
     ...normalizedSchema,
@@ -3885,7 +4304,8 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
     workflow: {
       ...normalizedSchema.workflow,
       ...loadedWorkflow ?? {}
-    }
+    },
+    type_workflows: [...normalizedSchema.type_workflows ?? [], ...loadedTypeWorkflows ?? []]
   });
   return {
     schema: mergedSchema,
@@ -4046,11 +4466,171 @@ var PmCliError = class extends Error {
   }
 };
 
+// dist/core/shared/serialization.js
+import crypto2 from "node:crypto";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "559577ae-1fd4-5045-8165-b89edb52bb21");
+  } catch (e2) {
+  }
+})();
+function sortObjectKeys(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"}]`;
+  }
+  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);
+    }
+  }
+  const obj = value;
+  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
+  const result = {};
+  for (const key of sortedKeys) {
+    const nested = obj[key];
+    if (nested === void 0) {
+      continue;
+    }
+    result[key] = sortObjectKeys(nested);
+  }
+  return result;
+}
+function stableStringify(value) {
+  return JSON.stringify(sortObjectKeys(value));
+}
+function stableValueEquals(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  if (left instanceof RegExp || right instanceof RegExp) {
+    return left instanceof RegExp && right instanceof RegExp && left.toString() === right.toString();
+  }
+  if (left instanceof Date || right instanceof Date) {
+    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+  }
+  if (left instanceof Set || right instanceof Set) {
+    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) {
+      let found = false;
+      for (let index = 0; index < rightValues.length; index += 1) {
+        if (matched.has(index)) {
+          continue;
+        }
+        if (stableValueEquals(leftValue, rightValues[index])) {
+          matched.add(index);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (left instanceof Map || right instanceof Map) {
+    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()) {
+      let found = false;
+      for (let index = 0; index < rightEntries.length; index += 1) {
+        if (matched.has(index)) {
+          continue;
+        }
+        const [rightKey, rightValue] = rightEntries[index];
+        if (stableValueEquals(leftKey, rightKey) && stableValueEquals(leftValue, rightValue)) {
+          matched.add(index);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+      return false;
+    }
+    return left.every((value, index) => stableValueEquals(value, right[index]));
+  }
+  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;
+}
+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
 !(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] = "d7f0c9f9-7990-5b8a-a9f8-7dc98d976ecf");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "8b425415-1e39-5f2d-b23b-db8b2f0ba1c9");
   } catch (e2) {
   }
 })();
@@ -4161,6 +4741,20 @@ var runtimeFieldDefinition = vObject({
   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({
@@ -4179,6 +4773,7 @@ var runtimeSchemaSettings = vOptional(vObject({
     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({
@@ -4189,7 +4784,8 @@ var governanceSettings = vOptional(vObject({
   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)
+  create_default_type: vOptional(vString),
+  workflow_enforcement: vOptional(vLiteral("off", "warn", "strict"))
 }));
 var extensionPolicyOverride = vObject({
   name: vString,
@@ -4315,82 +4911,6 @@ function validateSettings(raw) {
   return { success: true, data: result.value };
 }
 
-// dist/core/shared/serialization.js
-import crypto2 from "node:crypto";
-!(function() {
-  try {
-    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9077bf31-377c-5b65-9e68-dd85503b2a0a");
-  } catch (e2) {
-  }
-})();
-function sortObjectKeys(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"}]`;
-  }
-  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);
-    }
-  }
-  const obj = value;
-  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
-  const result = {};
-  for (const key of sortedKeys) {
-    const nested = obj[key];
-    if (nested === void 0) {
-      continue;
-    }
-    result[key] = sortObjectKeys(nested);
-  }
-  return result;
-}
-function stableStringify(value) {
-  return JSON.stringify(sortObjectKeys(value));
-}
-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/item/item-type-definition.js
 !(function() {
   try {
@@ -4483,11 +5003,12 @@ function normalizeItemTypeDefinition(definition, options = {}) {
 !(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] = "2f269589-996e-551b-85ef-14bd6eb8aebe");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "bb310f96-79d3-5bd1-a4aa-b8a8ac741afb");
   } catch (e2) {
   }
 })();
 var SETTINGS_WRITE_OP = "settings:write";
+var SETTINGS_PERSIST_SOURCE_SYMBOL = /* @__PURE__ */ Symbol("pm.settings.persist_source");
 function resolveGovernanceKnobsFromPreset(preset) {
   return structuredClone(GOVERNANCE_PRESET_DEFAULTS[preset]);
 }
@@ -4497,9 +5018,19 @@ function normalizeGovernancePreset(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;
+  }
+  return base;
+}
 function normalizeGovernanceForPersist(governance) {
   if (governance.preset === "custom") {
-    return {
+    return withGovernanceExtras({
       preset: "custom",
       ownership_enforcement: governance.ownership_enforcement,
       create_mode_default: governance.create_mode_default,
@@ -4507,15 +5038,23 @@ function normalizeGovernanceForPersist(governance) {
       parent_reference: governance.parent_reference,
       metadata_profile: governance.metadata_profile,
       force_required_for_stale_lock: governance.force_required_for_stale_lock
-    };
+    }, governance);
   }
-  return {
+  return withGovernanceExtras({
     preset: governance.preset
+  }, governance);
+}
+function resolveGovernanceExtras(rawGovernance) {
+  const createDefaultType = typeof rawGovernance.create_default_type === "string" ? rawGovernance.create_default_type.trim() : void 0;
+  return {
+    create_default_type: createDefaultType && createDefaultType.length > 0 ? createDefaultType : void 0,
+    workflow_enforcement: rawGovernance.workflow_enforcement === "off" || rawGovernance.workflow_enforcement === "warn" || rawGovernance.workflow_enforcement === "strict" ? rawGovernance.workflow_enforcement : void 0
   };
 }
 function resolveGovernanceKnobs(settings) {
   const rawGovernance = settings.governance ?? {};
   const preset = normalizeGovernancePreset(rawGovernance.preset);
+  const extras = resolveGovernanceExtras(rawGovernance);
   if (preset === "custom") {
     const baseline = resolveGovernanceKnobsFromPreset("default");
     return {
@@ -4525,12 +5064,14 @@ function resolveGovernanceKnobs(settings) {
       close_validation_default: rawGovernance.close_validation_default ?? baseline.close_validation_default,
       parent_reference: rawGovernance.parent_reference ?? baseline.parent_reference,
       metadata_profile: rawGovernance.metadata_profile ?? baseline.metadata_profile,
-      force_required_for_stale_lock: rawGovernance.force_required_for_stale_lock ?? baseline.force_required_for_stale_lock
+      force_required_for_stale_lock: rawGovernance.force_required_for_stale_lock ?? baseline.force_required_for_stale_lock,
+      ...extras
     };
   }
   return {
     preset,
-    ...resolveGovernanceKnobsFromPreset(preset)
+    ...resolveGovernanceKnobsFromPreset(preset),
+    ...extras
   };
 }
 function cloneDefaults() {
@@ -4542,6 +5083,64 @@ function normalizeSearchMutationRefreshPolicy(value) {
   }
   return SETTINGS_DEFAULTS.search.mutation_refresh_policy;
 }
+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 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(),
@@ -4787,8 +5386,10 @@ function mergeSettings(settings) {
     }
   };
 }
-function serializeSettings(settings) {
+function serializeSettings(settings, options = {}) {
   const governance = resolveGovernanceKnobs(settings);
+  const normalizedSchema = normalizeRuntimeSchemaSettings(settings.schema);
+  const persistedFileBackedSections = resolvePersistedFileBackedSchemaSections(settings, options.persist_source);
   const normalizedSettings = {
     ...settings,
     item_format: "toon",
@@ -4805,9 +5406,14 @@ function serializeSettings(settings) {
     governance,
     agent_guidance: normalizeAgentGuidanceSettings(settings.agent_guidance),
     item_types: {
-      definitions: normalizeItemTypeDefinitions(settings.item_types?.definitions)
+      definitions: persistedFileBackedSections.item_type_definitions
+    },
+    schema: {
+      ...normalizedSchema,
+      statuses: persistedFileBackedSections.schema_statuses,
+      fields: persistedFileBackedSections.schema_fields,
+      type_workflows: persistedFileBackedSections.schema_type_workflows
     },
-    schema: normalizeRuntimeSchemaSettings(settings.schema),
     search: {
       ...SETTINGS_DEFAULTS.search,
       ...settings.search,
@@ -4873,7 +5479,9 @@ function serializeSettings(settings) {
     "close_validation_default",
     "parent_reference",
     "metadata_profile",
-    "force_required_for_stale_lock"
+    "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"]);
@@ -4899,6 +5507,7 @@ function serializeSettings(settings) {
     "statuses",
     "fields",
     "workflow",
+    "type_workflows",
     "unknown_field_policy"
   ]);
   ordered.schema.files = orderObject(ordered.schema.files ?? {}, ["types", "statuses", "fields", "workflows"]);
@@ -5002,6 +5611,7 @@ async function readSettingsWithMetadata(pmRoot) {
       },
       schema: loadedSchemaSections.schema
     };
+    attachSettingsPersistSourceSnapshot(settings, buildSettingsPersistSourceSnapshot(validated.data, settings));
     return {
       settings,
       metadata: {
@@ -5022,7 +5632,9 @@ async function readSettings(pmRoot) {
 }
 async function writeSettings(pmRoot, settings, op = SETTINGS_WRITE_OP) {
   const settingsPath = getSettingsPath(pmRoot);
-  await writeFileAtomic(settingsPath, serializeSettings(settings));
+  await writeFileAtomic(settingsPath, serializeSettings(settings, {
+    persist_source: getSettingsPersistSourceSnapshot(settings)
+  }));
   await runActiveOnWriteHooks({
     path: settingsPath,
     scope: "project",
@@ -5038,6 +5650,7 @@ export {
   appendLineAtomic,
   removeFileIfExists,
   isPathWithinDirectory,
+  resolvePmPackageRootFromModule,
   KNOWN_EXTENSION_CAPABILITIES,
   EXTENSION_CAPABILITY_CONTRACT,
   KNOWN_EXTENSION_POLICY_MODES,
@@ -5083,10 +5696,12 @@ export {
   asRecordOrNull,
   parseUnknownExtensionCapabilityWarning,
   parseLegacyExtensionCapabilityAliasWarning,
+  createEmptyExtensionRegistrationRegistry,
   runBeforeCommandHooks,
   runAfterCommandHooks,
   nextExtensionReloadToken,
   resolveExtensionRoots,
+  discoverExtensions,
   loadExtensions,
   activateExtensions,
   setActiveExtensionHooks,
@@ -5100,6 +5715,9 @@ export {
   setActiveCommandContext,
   setActiveCommandResult,
   getActiveCommandResult,
+  recordAfterCommandAffectedItem,
+  projectAfterCommandItemSnapshot,
+  consumeAfterCommandAffectedItems,
   clearActiveExtensionHooks,
   runActiveOnWriteHooks,
   runActiveOnReadHooks,
@@ -5115,6 +5733,7 @@ export {
   BUILTIN_ITEM_TYPE_VALUES,
   ITEM_TYPE_VALUES,
   STATUS_VALUES,
+  RUNTIME_STATUS_ROLE_VALUES,
   DEPENDENCY_KIND_VALUES,
   SCOPE_VALUES,
   RISK_VALUES,
@@ -5133,6 +5752,7 @@ export {
   strictPolicyCommand,
   normalizeItemTypeDefinition,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
+  DEFAULT_RUNTIME_STATUS_DEFINITIONS,
   normalizeRuntimeSchemaSettings,
   filePathForSchemaSection,
   ensureRuntimeSchemaFileScaffold,
@@ -5143,6 +5763,7 @@ export {
   statusIsTerminal,
   PmCliError,
   stableStringify,
+  stableValueEquals,
   sha256Hex,
   orderObject,
   resolveGovernanceKnobs,
@@ -5150,4 +5771,4 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-LSXGH6NE.js.map
+//# sourceMappingURL=chunk-U5SXYXSY.js.map