@unbrained/pm-cli 2026.7.3 → 2026.7.5

package/dist/cli-bundle/chunks/{chunk-KHVGM5CS.js → chunk-5VVUKE3U.js}

@@ -172,12 +172,22 @@ 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
 !(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] = "add4a412-10a4-5c04-b3a2-998cc74fdd38");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0fdb02e4-60e7-5f4c-9f06-d2ec2f03f792");
   } catch (e2) {
   }
 })();
@@ -265,7 +275,7 @@ function createDefaultExtensionGovernancePolicy() {
 !(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] = "a6013abb-eda6-5fdb-a9c3-2216599fb9b7");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "3a76b425-d6cd-5ba4-a77f-bd95a7deb473");
   } catch (e2) {
   }
 })();
@@ -464,7 +474,8 @@ var SETTINGS_DEFAULTS = {
   author_default: "",
   item_format: "toon",
   locks: {
-    ttl_seconds: 1800
+    ttl_seconds: 1800,
+    wait_ms: 3e3
   },
   checkpoints: {
     retention_days: 14
@@ -667,7 +678,7 @@ function resolveTelemetryErrorCategory(errorCode) {
 !(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] = "46812059-b93e-5599-a222-4ac0de6f4911");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "6e5bac32-d895-5fce-9fc0-9c0615399b61");
   } catch (e2) {
   }
 })();
@@ -880,7 +891,7 @@ 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] = "e9e27e2d-967c-5e17-8266-d661f65b78ac");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "563d02b1-6a96-539c-9e2c-dc118aa5dd72");
   } catch (e2) {
   }
 })();
@@ -1026,116 +1037,85 @@ var UPDATE_COMMAND_OPTION_ALIASES = {
   "allow-audit-update": "allowAuditUpdate",
   allow_audit_update: "allowAuditUpdate"
 };
-var CREATE_COMMAND_OPTION_FLAG_LABELS = {
-  title: "--title",
-  description: "--description",
-  type: "--type",
-  status: "--status",
-  priority: "--priority",
-  tags: "--tags",
-  body: "--body",
-  deadline: "--deadline",
-  estimatedMinutes: "--estimate/--estimated-minutes",
-  acceptanceCriteria: "--acceptance-criteria/--ac",
-  definitionOfReady: "--definition-of-ready",
-  order: "--order/--rank",
-  goal: "--goal",
-  objective: "--objective",
-  value: "--value",
-  impact: "--impact",
-  outcome: "--outcome",
-  whyNow: "--why-now",
-  author: "--author",
-  message: "--message",
-  assignee: "--assignee",
-  parent: "--parent",
-  reviewer: "--reviewer",
-  risk: "--risk",
-  confidence: "--confidence",
-  sprint: "--sprint",
-  release: "--release",
-  blockedBy: "--blocked-by",
-  blockedReason: "--blocked-reason",
-  unblockNote: "--unblock-note",
-  reporter: "--reporter",
-  severity: "--severity",
-  environment: "--environment",
-  reproSteps: "--repro-steps",
-  resolution: "--resolution",
-  expectedResult: "--expected-result",
-  actualResult: "--actual-result",
-  affectedVersion: "--affected-version",
-  fixedVersion: "--fixed-version",
-  component: "--component",
-  regression: "--regression",
-  customerImpact: "--customer-impact",
-  dep: "--dep",
-  comment: "--comment",
-  note: "--note",
-  learning: "--learning",
-  file: "--file",
-  test: "--test",
-  doc: "--doc",
-  reminder: "--reminder",
-  event: "--event",
-  typeOption: "--type-option"
-};
-var UPDATE_COMMAND_OPTION_FLAG_LABELS = {
-  title: "--title",
-  description: "--description",
-  body: "--body",
-  status: "--status",
-  closeReason: "--close-reason",
-  priority: "--priority",
-  type: "--type",
-  tags: "--tags",
-  deadline: "--deadline",
-  estimatedMinutes: "--estimate/--estimated-minutes",
-  acceptanceCriteria: "--acceptance-criteria/--ac",
-  definitionOfReady: "--definition-of-ready",
-  order: "--order/--rank",
-  goal: "--goal",
-  objective: "--objective",
-  value: "--value",
-  impact: "--impact",
-  outcome: "--outcome",
-  whyNow: "--why-now",
-  assignee: "--assignee",
-  parent: "--parent",
-  reviewer: "--reviewer",
-  risk: "--risk",
-  confidence: "--confidence",
-  sprint: "--sprint",
-  release: "--release",
-  blockedBy: "--blocked-by",
-  blockedReason: "--blocked-reason",
-  unblockNote: "--unblock-note",
-  reporter: "--reporter",
-  severity: "--severity",
-  environment: "--environment",
-  reproSteps: "--repro-steps",
-  resolution: "--resolution",
-  expectedResult: "--expected-result",
-  actualResult: "--actual-result",
-  affectedVersion: "--affected-version",
-  fixedVersion: "--fixed-version",
-  component: "--component",
-  regression: "--regression",
-  customerImpact: "--customer-impact",
-  comment: "--comment",
-  note: "--note",
-  learning: "--learning",
-  file: "--file",
-  test: "--test",
-  doc: "--doc",
-  reminder: "--reminder",
-  event: "--event",
-  typeOption: "--type-option",
-  allowAuditUpdate: "--allow-audit-update",
-  author: "--author",
-  message: "--message",
-  force: "--force"
-};
+var COMMON_MUTATION_COMMAND_OPTION_FLAG_LABEL_ENTRIES = [
+  ["deadline", "--deadline"],
+  ["estimatedMinutes", "--estimate/--estimated-minutes"],
+  ["acceptanceCriteria", "--acceptance-criteria/--ac"],
+  ["definitionOfReady", "--definition-of-ready"],
+  ["order", "--order/--rank"],
+  ["goal", "--goal"],
+  ["objective", "--objective"],
+  ["value", "--value"],
+  ["impact", "--impact"],
+  ["outcome", "--outcome"],
+  ["whyNow", "--why-now"],
+  ["assignee", "--assignee"],
+  ["parent", "--parent"],
+  ["reviewer", "--reviewer"],
+  ["risk", "--risk"],
+  ["confidence", "--confidence"],
+  ["sprint", "--sprint"],
+  ["release", "--release"],
+  ["blockedBy", "--blocked-by"],
+  ["blockedReason", "--blocked-reason"],
+  ["unblockNote", "--unblock-note"],
+  ["reporter", "--reporter"],
+  ["severity", "--severity"],
+  ["environment", "--environment"],
+  ["reproSteps", "--repro-steps"],
+  ["resolution", "--resolution"],
+  ["expectedResult", "--expected-result"],
+  ["actualResult", "--actual-result"],
+  ["affectedVersion", "--affected-version"],
+  ["fixedVersion", "--fixed-version"],
+  ["component", "--component"],
+  ["regression", "--regression"],
+  ["customerImpact", "--customer-impact"]
+];
+var LINKED_RESOURCE_COMMAND_OPTION_FLAG_LABEL_ENTRIES = [
+  ["comment", "--comment"],
+  ["note", "--note"],
+  ["learning", "--learning"],
+  ["file", "--file"],
+  ["test", "--test"],
+  ["doc", "--doc"],
+  ["reminder", "--reminder"],
+  ["event", "--event"],
+  ["typeOption", "--type-option"]
+];
+function commandOptionLabelMap(entries) {
+  return Object.fromEntries(entries);
+}
+var CREATE_COMMAND_OPTION_FLAG_LABELS = commandOptionLabelMap([
+  ["title", "--title"],
+  ["description", "--description"],
+  ["type", "--type"],
+  ["status", "--status"],
+  ["priority", "--priority"],
+  ["tags", "--tags"],
+  ["body", "--body"],
+  ...COMMON_MUTATION_COMMAND_OPTION_FLAG_LABEL_ENTRIES,
+  ["author", "--author"],
+  ["message", "--message"],
+  ["dep", "--dep"],
+  ...LINKED_RESOURCE_COMMAND_OPTION_FLAG_LABEL_ENTRIES
+]);
+var UPDATE_COMMAND_OPTION_FLAG_LABELS = commandOptionLabelMap([
+  ["title", "--title"],
+  ["description", "--description"],
+  ["body", "--body"],
+  ["status", "--status"],
+  ["closeReason", "--close-reason"],
+  ["priority", "--priority"],
+  ["type", "--type"],
+  ["tags", "--tags"],
+  ...COMMON_MUTATION_COMMAND_OPTION_FLAG_LABEL_ENTRIES,
+  ...LINKED_RESOURCE_COMMAND_OPTION_FLAG_LABEL_ENTRIES,
+  ["allowAuditUpdate", "--allow-audit-update"],
+  ["author", "--author"],
+  ["message", "--message"],
+  ["force", "--force"]
+]);
 function normalizeCommandOptionToken(value) {
   return value.trim().replace(/^--+/, "").toLowerCase();
 }
@@ -1280,6 +1260,27 @@ function resolveDefinitionOptions(normalizedDefinition, existing) {
 function resolveDefinitionCommandOptionPolicies(normalizedDefinition, existing) {
   return normalizedDefinition.command_option_policies ? normalizedDefinition.command_option_policies : existing?.command_option_policies ? [...existing.command_option_policies] : [];
 }
+function buildResolvedTypeDefinition(normalizedDefinition, existing) {
+  const keepName = existing?.name ?? normalizedDefinition.name;
+  const description = normalizedDefinition.description ?? existing?.description;
+  const defaultStatus = normalizedDefinition.default_status ?? existing?.default_status;
+  const resolvedDefinition = {
+    name: keepName,
+    folder: normalizedDefinition.folder ?? existing?.folder ?? toDefaultFolder(keepName),
+    aliases: normalizeItemTypeStringList([...existing?.aliases ?? [], ...normalizedDefinition.aliases ?? []]),
+    required_create_fields: resolveDefinitionRequiredCreateFields(normalizedDefinition, existing),
+    required_create_repeatables: resolveDefinitionRequiredCreateRepeatables(normalizedDefinition, existing),
+    options: resolveDefinitionOptions(normalizedDefinition, existing),
+    command_option_policies: resolveDefinitionCommandOptionPolicies(normalizedDefinition, existing)
+  };
+  if (description) {
+    resolvedDefinition.description = description;
+  }
+  if (defaultStatus) {
+    resolvedDefinition.default_status = defaultStatus;
+  }
+  return resolvedDefinition;
+}
 function applyTypeDefinitions(source, target) {
   for (const rawDefinition of source) {
     const normalizedDefinition = normalizeTypeDefinition(rawDefinition);
@@ -1288,25 +1289,7 @@ function applyTypeDefinitions(source, target) {
     }
     const lowerName = normalizedDefinition.name.toLowerCase();
     const existing = target.get(lowerName);
-    const keepName = existing?.name ?? normalizedDefinition.name;
-    const folder = normalizedDefinition.folder ?? existing?.folder ?? toDefaultFolder(keepName);
-    const aliases = normalizeItemTypeStringList([
-      ...existing?.aliases ?? [],
-      ...normalizedDefinition.aliases ?? []
-    ]);
-    const defaultStatus = normalizedDefinition.default_status ?? existing?.default_status;
-    const description = normalizedDefinition.description ?? existing?.description;
-    target.set(lowerName, {
-      name: keepName,
-      ...description ? { description } : {},
-      ...defaultStatus ? { default_status: defaultStatus } : {},
-      folder,
-      aliases,
-      required_create_fields: resolveDefinitionRequiredCreateFields(normalizedDefinition, existing),
-      required_create_repeatables: resolveDefinitionRequiredCreateRepeatables(normalizedDefinition, existing),
-      options: resolveDefinitionOptions(normalizedDefinition, existing),
-      command_option_policies: resolveDefinitionCommandOptionPolicies(normalizedDefinition, existing)
-    });
+    target.set(lowerName, buildResolvedTypeDefinition(normalizedDefinition, existing));
   }
 }
 function collectExtensionTypeDefinitions(registrations) {
@@ -1377,55 +1360,62 @@ function resolveTypeDefinition(typeName, registry) {
   }
   return registry.by_type[resolvedName];
 }
-function resolveCommandOptionPolicyState(typeDefinition, command, baseRequiredOptions) {
-  const errors = [];
-  const required = /* @__PURE__ */ new Set();
-  const hidden = /* @__PURE__ */ new Set();
-  const disabled = /* @__PURE__ */ new Set();
+function applyBaseRequiredCommandOptions(state, typeDefinition, command, baseRequiredOptions) {
   for (const rawBase of baseRequiredOptions) {
     const canonical = canonicalizeCommandOptionKey(command, rawBase);
-    if (!canonical) {
-      errors.push(`Unsupported base required option "${rawBase}" for command "${command}" on type "${typeDefinition.name}"`);
+    if (canonical) {
+      state.required.add(canonical);
       continue;
     }
-    required.add(canonical);
+    state.errors.push(`Unsupported base required option "${rawBase}" for command "${command}" on type "${typeDefinition.name}"`);
+  }
+}
+function applyBooleanPolicySet(target, option, enabled) {
+  if (enabled) {
+    target.add(option);
+    return;
+  }
+  target.delete(option);
+}
+function applyCommandOptionPolicy(state, typeDefinition, command, policy) {
+  const canonical = canonicalizeCommandOptionKey(command, policy.option);
+  if (!canonical) {
+    state.errors.push(`Unsupported command_option_policies option "${policy.option}" for command "${command}" on type "${typeDefinition.name}"`);
+    return;
+  }
+  if (policy.required !== void 0) {
+    applyBooleanPolicySet(state.required, canonical, policy.required);
   }
+  if (policy.visible !== void 0) {
+    applyBooleanPolicySet(state.hidden, canonical, !policy.visible);
+  }
+  if (policy.enabled !== void 0) {
+    applyBooleanPolicySet(state.disabled, canonical, !policy.enabled);
+  }
+}
+function applyCommandOptionPolicies(state, typeDefinition, command) {
   for (const policy of typeDefinition.command_option_policies) {
-    if (policy.command !== command) {
-      continue;
-    }
-    const canonical = canonicalizeCommandOptionKey(command, policy.option);
-    if (!canonical) {
-      errors.push(`Unsupported command_option_policies option "${policy.option}" for command "${command}" on type "${typeDefinition.name}"`);
-      continue;
-    }
-    if (policy.required !== void 0) {
-      if (policy.required) {
-        required.add(canonical);
-      } else {
-        required.delete(canonical);
-      }
-    }
-    if (policy.visible !== void 0) {
-      if (policy.visible) {
-        hidden.delete(canonical);
-      } else {
-        hidden.add(canonical);
-      }
-    }
-    if (policy.enabled !== void 0) {
-      if (policy.enabled) {
-        disabled.delete(canonical);
-      } else {
-        disabled.add(canonical);
-      }
+    if (policy.command === command) {
+      applyCommandOptionPolicy(state, typeDefinition, command, policy);
     }
   }
-  for (const option of required) {
-    if (disabled.has(option)) {
-      errors.push(`Option "${option}" cannot be both required and disabled for command "${command}" on type "${typeDefinition.name}"`);
+}
+function appendRequiredDisabledPolicyErrors(state, typeDefinition, command) {
+  for (const option of state.required) {
+    if (state.disabled.has(option)) {
+      state.errors.push(`Option "${option}" cannot be both required and disabled for command "${command}" on type "${typeDefinition.name}"`);
     }
   }
+}
+function resolveCommandOptionPolicyState(typeDefinition, command, baseRequiredOptions) {
+  const errors = [];
+  const required = /* @__PURE__ */ new Set();
+  const hidden = /* @__PURE__ */ new Set();
+  const disabled = /* @__PURE__ */ new Set();
+  const state = { required, hidden, disabled, errors };
+  applyBaseRequiredCommandOptions(state, typeDefinition, command, baseRequiredOptions);
+  applyCommandOptionPolicies(state, typeDefinition, command);
+  appendRequiredDisabledPolicyErrors(state, typeDefinition, command);
   return {
     required: [...required],
     hidden: [...hidden].sort((left, right) => left.localeCompare(right)),
@@ -1632,7 +1622,7 @@ function getTestRunResultPath(pmRoot, runId) {
 !(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] = "d9690125-4747-50c0-850b-610233f6143d");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f9d3b558-3b10-5f06-a2d1-7ceb16119586");
   } catch (e2) {
   }
 })();
@@ -1690,6 +1680,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() {
@@ -1743,6 +1750,139 @@ function levenshteinDistanceWithinLimit(left, right, limit) {
   return result <= limit ? result : null;
 }
 
+// dist/core/extensions/extension-capability-aliases.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] = "5723464e-1f10-5a39-96a9-787c0052a036");
+  } catch (e2) {
+  }
+})();
+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() {
   try {
@@ -2416,177 +2556,44 @@ 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
+// dist/core/extensions/extension-policy.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] = "5723464e-1f10-5a39-96a9-787c0052a036");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "dbc43b74-6872-52c3-859a-64fe84c02b5b");
   } catch (e2) {
   }
 })();
-function normalizeNames(values) {
-  return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort((a, b) => a.localeCompare(b));
+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;
-}
-function collectUnknownExtensionCapabilities(capabilities) {
-  return capabilities.filter((capability) => !isKnownExtensionCapability(capability));
-}
-function resolveLegacyExtensionCapabilityAlias(capability) {
-  const normalized = capability.trim().toLowerCase();
   if (normalized.length === 0) {
-    return null;
+    return "";
   }
-  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 segments = normalized.split(/[.:/]/).map((segment) => segment.replace(/[\s_-]+/g, "")).filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return "";
   }
-  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
-  };
+  if (segments.length === 1) {
+    return segments[0];
+  }
+  return `${segments[0]}.${segments.slice(1).join("")}`;
 }
-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-policy.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] = "dbc43b74-6872-52c3-859a-64fe84c02b5b");
-  } catch (e2) {
-  }
-})();
-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;
+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";
 }
@@ -3023,7 +3030,7 @@ function evaluateExtensionPolicyForRegistration(policy, extension, surface, meth
 !(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] = "c04aa899-5cba-5907-be3e-4db7c63b7f13");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "07458218-1762-56b2-932e-adfacc4fa916");
   } catch (e2) {
   }
 })();
@@ -3398,14 +3405,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) {
@@ -3453,13 +3460,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);
@@ -3475,7 +3482,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}`);
@@ -3670,7 +3677,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);
@@ -3695,6 +3703,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 = {
@@ -3707,18 +3717,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 });
+  }
+  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;
   }
-  const defaultExport = asRecordLoose(moduleRecord.default);
-  if (defaultExport && typeof defaultExport.activate === "function") {
-    return toActivatableExtension(defaultExport);
+  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";
@@ -4876,10 +4946,21 @@ 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] = "7cc05bac-f673-59a1-9d51-64361cf5a939");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "4e149e81-498e-561d-8c32-c3f3aec2e2d2");
   } catch (e2) {
   }
 })();
+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)}`;
@@ -4942,10 +5023,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) {
@@ -4970,347 +5057,99 @@ function reconcileExtensionCapabilityUsage(loaded, activation) {
   return reconciliations;
 }
 
-// dist/core/extensions/index.js
+// dist/core/schema/runtime-schema.js
+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] = "abe62b94-a55a-5cdf-8f1a-34360ddc4c25");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "917b7841-d25b-594e-9c0e-dbecbf1a3fbe");
   } catch (e2) {
   }
 })();
-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;
-}
-function setActiveExtensionPreflight(preflight) {
-  activeExtensionPreflight = preflight;
-}
-function setActiveExtensionServices(services) {
-  activeExtensionServices = services;
-}
-function setActiveExtensionRenderers(renderers) {
-  activeExtensionRenderers = renderers;
+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 setActiveExtensionRegistrations(registrations) {
-  activeExtensionRegistrations = registrations;
+function normalizeStatusToken(value) {
+  return typeof value === "string" ? value.trim().toLowerCase().replaceAll(/[\s-]+/g, "_") : "";
 }
-function getActiveExtensionRegistrations() {
-  return activeExtensionRegistrations;
+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 setActiveCommandContext(context) {
-  activeCommandContext = context;
+function stripFlagPrefix(value) {
+  return value.startsWith("--") ? value.slice(2) : value;
 }
-function setActiveCommandResult(result) {
-  activeCommandResult = result;
+function normalizeCliToken(value) {
+  return typeof value === "string" ? stripFlagPrefix(value.trim().toLowerCase().replaceAll(/[\s_]+/g, "-")) : "";
 }
-function getActiveCommandResult() {
-  return activeCommandResult;
+function keyToDefaultCliFlag(value) {
+  return value.replaceAll("_", "-");
 }
-function recordAfterCommandAffectedItem(item) {
-  if (!item || (activeExtensionHooks?.afterCommand?.length ?? 0) === 0) {
-    return;
+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;
   }
-  activeAfterCommandAffectedItems.push(item);
+  const [first, ...rest] = segments;
+  return `${first}${rest.map((segment) => `${segment.slice(0, 1).toUpperCase()}${segment.slice(1)}`).join("")}`;
 }
-function projectAfterCommandItemSnapshot(metadata, changedFields) {
-  if (!metadata || !metadata.id) {
-    return {};
+function normalizeRuntimeStatusDefinition(definition, fallbackOrder) {
+  const id = normalizeStatusId(definition.id);
+  if (!id) {
+    return null;
   }
-  const snapshot = {
-    id: metadata.id,
-    type: metadata.type,
-    status: metadata.status
+  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
   };
-  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;
+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 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 [];
+  const from = normalizeStatusToken(pair[0]);
+  const to = normalizeStatusToken(pair[1]);
+  if (from.length === 0 || to.length === 0) {
+    return;
   }
-  return runOnWriteHooks(activeExtensionHooks, context);
-}
-async function runActiveOnReadHooks(context) {
-  if (!activeExtensionHooks) {
-    return [];
+  if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
+    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";
-!(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] = "917b7841-d25b-594e-9c0e-dbecbf1a3fbe");
-  } catch (e2) {
-  }
-})();
-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() : "";
@@ -5803,1664 +5642,6 @@ function statusIsTerminal(status, registry) {
   return registry.terminal_statuses.has(normalized);
 }
 
-// dist/core/shared/errors.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] = "45a4107c-5ef6-5d5c-9798-6df69f0edec3");
-  } catch (e2) {
-  }
-})();
-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() {
-  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] = "54cbe570-d9f5-5515-8d0c-0fce0e06fe03");
-  } catch (e2) {
-  }
-})();
-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
-!(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] = "31c04c84-ab93-5423-8425-f01cdbc48a9f");
-  } catch (e2) {
-  }
-})();
-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
-!(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] = "33f2ca4e-022c-5fc2-9938-a3fb389c1b93");
-  } catch (e2) {
-  }
-})();
-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";
-!(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] = "406f2d48-4969-5666-9e95-c71103f541c5");
-  } catch (e2) {
-  }
-})();
-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
-!(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] = "4232868d-1e9d-51a3-abbe-3d9a3d1acae1");
-  } catch (e2) {
-  }
-})();
-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 global2 = normalizePmMaxVersionExceededModeValue2(value.global);
-    const project = normalizePmMaxVersionExceededModeValue2(value.project);
-    if (global2 === void 0 && project === void 0) {
-      return void 0;
-    }
-    return {
-      ...global2 !== void 0 ? { global: global2 } : {},
-      ...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,
@@ -7471,13 +5652,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,
@@ -7493,15 +5678,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,
@@ -7511,6 +5699,8 @@ export {
   PLAN_STEP_LINK_KIND_VALUES,
   CONTEXT_DEPTH_VALUES,
   CONTEXT_SECTION_VALUES,
+  normalizeItemTypeDefinition,
+  COMMON_MUTATION_COMMAND_OPTION_KEYS,
   canonicalizeCommandOptionKey,
   commandOptionFlagLabel,
   toDefaultFolder,
@@ -7545,69 +5735,55 @@ 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-KHVGM5CS.js.map
+//# sourceMappingURL=chunk-5VVUKE3U.js.map