@unbrained/pm-cli 2026.6.23 → 2026.6.30

package/dist/cli-bundle/chunks/{chunk-MJTSZKK5.js → chunk-SNUK7H5J.js}

@@ -5,10 +5,11 @@ import crypto 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] = "4ddafbee-315f-5aa0-b08f-d4d7a82cfe8d");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "4ba3885b-85fc-5941-bf52-6c70b2bb5c2a");
   } catch (e2) {
   }
 })();
+var WINDOWS_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100];
 async function ensureDir(dirPath) {
   await fs.mkdir(dirPath, { recursive: true });
 }
@@ -38,6 +39,26 @@ async function writeFileAtomic(targetPath, contents) {
   try {
     await fs.rename(tempPath, targetPath);
   } catch (error) {
+    if (process.platform === "win32" && (isErrno(error, "EPERM") || isErrno(error, "EBUSY"))) {
+      let lastError = error;
+      for (const delayMs of WINDOWS_RENAME_RETRY_DELAYS_MS) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        try {
+          await fs.rename(tempPath, targetPath);
+          return;
+        } catch (retryError) {
+          lastError = retryError;
+          if (!isErrno(retryError, "EPERM") && !isErrno(retryError, "EBUSY")) {
+            break;
+          }
+        }
+      }
+      try {
+        await fs.unlink(tempPath);
+      } catch {
+      }
+      throw lastError;
+    }
     if (isErrno(error, "EXDEV")) {
       try {
         await fs.copyFile(tempPath, targetPath);
@@ -156,7 +177,7 @@ function resolvePmCliVersion(metaUrl, fallbackRelativeSegments = []) {
 !(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] = "a8e01f7b-34b8-58a6-b894-3fcb8bad7d73");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "add4a412-10a4-5c04-b3a2-998cc74fdd38");
   } catch (e2) {
   }
 })();
@@ -197,6 +218,7 @@ var KNOWN_EXTENSION_POLICY_SURFACES = [
   "schema.itemfields",
   "schema.itemtypes",
   "schema.migrations",
+  "schema.profiles",
   "parser.override",
   "preflight.override",
   "services.override",
@@ -542,103 +564,921 @@ var SETTINGS_DEFAULTS = {
       model: "",
       top_k: 20
     }
-  },
-  providers: {
-    openai: {
-      base_url: "",
-      api_key: "",
-      model: ""
-    },
-    ollama: {
-      base_url: "",
-      model: ""
+  },
+  providers: {
+    openai: {
+      base_url: "",
+      api_key: "",
+      model: ""
+    },
+    ollama: {
+      base_url: "",
+      model: ""
+    }
+  },
+  context: {
+    default_depth: "brief",
+    activity_limit: 10,
+    stale_threshold_days: 7,
+    sections: {
+      hierarchy: true,
+      activity: true,
+      progress: true,
+      recently_created: true,
+      unparented: true,
+      blockers: true,
+      files: true,
+      workload: true,
+      staleness: true,
+      tests: true
+    }
+  },
+  vector_store: {
+    adapter: "",
+    collection_name: "pm_items",
+    qdrant: {
+      url: "",
+      api_key: ""
+    },
+    lancedb: {
+      path: ""
+    }
+  }
+};
+var EMPTY_CANONICAL_DOCUMENT = {
+  metadata: {},
+  body: ""
+};
+var EXIT_CODE = {
+  SUCCESS: 0,
+  GENERIC_FAILURE: 1,
+  USAGE: 2,
+  NOT_FOUND: 3,
+  CONFLICT: 4,
+  DEPENDENCY_FAILED: 5
+};
+var TELEMETRY_ERROR_CATEGORY_BY_CODE = Object.freeze({
+  unknown_command: "usage",
+  unknown_option: "usage",
+  missing_required_option: "usage",
+  missing_required_argument: "usage",
+  invalid_command_usage: "usage",
+  linked_test_value_not_quoted: "usage",
+  invalid_argument_value: "validation",
+  health_findings: "validation",
+  validation_findings: "validation",
+  close_through_update: "validation",
+  no_update_fields: "validation",
+  unsupported_update_option: "validation",
+  tracker_not_initialized: "validation",
+  item_not_found: "validation",
+  ownership_conflict: "conflict",
+  lock_conflict: "conflict",
+  terminal_state_conflict: "conflict",
+  dependency_failed: "runtime",
+  command_failed: "runtime",
+  unknown_error: "runtime"
+});
+function resolveTelemetryErrorCategory(errorCode) {
+  const normalized = (errorCode ?? "").trim().toLowerCase();
+  if (normalized.length === 0) {
+    return "unknown";
+  }
+  const explicit = TELEMETRY_ERROR_CATEGORY_BY_CODE[normalized];
+  if (typeof explicit === "string") {
+    return explicit;
+  }
+  if (normalized.includes("conflict") || normalized.includes("locked")) {
+    return "conflict";
+  }
+  if (normalized.startsWith("unknown_") || normalized.startsWith("missing_required_")) {
+    return "usage";
+  }
+  if (normalized.startsWith("invalid_") || normalized.endsWith("_not_found") || normalized.includes("validation")) {
+    return "validation";
+  }
+  if (normalized.endsWith("_error") || normalized.endsWith("_failed")) {
+    return "runtime";
+  }
+  return "unknown";
+}
+
+// dist/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] = "46812059-b93e-5599-a222-4ac0de6f4911");
+  } catch (e2) {
+  }
+})();
+var BUILTIN_ITEM_TYPE_VALUES = [
+  "Epic",
+  "Feature",
+  "Task",
+  "Chore",
+  "Issue",
+  "Decision",
+  "Event",
+  "Reminder",
+  "Milestone",
+  "Meeting",
+  "Plan"
+];
+var ITEM_TYPE_VALUES = BUILTIN_ITEM_TYPE_VALUES;
+var STATUS_VALUES = [
+  "draft",
+  "open",
+  "in_progress",
+  "blocked",
+  "closed",
+  "canceled"
+];
+var RUNTIME_STATUS_ROLE_VALUES = [
+  "draft",
+  "active",
+  "blocked",
+  "terminal",
+  "terminal_done",
+  "terminal_canceled",
+  "default_open",
+  "default_close",
+  "default_cancel"
+];
+var RUNTIME_FIELD_TYPE_VALUES = ["string", "number", "boolean", "string_array"];
+var RUNTIME_FIELD_COMMAND_VALUES = ["create", "update", "update_many", "list", "search", "calendar", "context"];
+var RUNTIME_UNKNOWN_FIELD_POLICY_VALUES = ["allow", "warn", "reject"];
+var DEPENDENCY_KIND_VALUES = [
+  "blocks",
+  "parent",
+  "child",
+  "parent_child",
+  "child_of",
+  "related",
+  "related_to",
+  "discovered_from",
+  "blocked_by",
+  "incident_from",
+  "epic",
+  "supersedes",
+  "task"
+];
+var SCOPE_VALUES = ["project", "global"];
+var RISK_VALUES = ["low", "medium", "high", "critical"];
+var ISSUE_SEVERITY_VALUES = ["low", "medium", "high", "critical"];
+var CONFIDENCE_TEXT_VALUES = ["low", "medium", "high"];
+var GOVERNANCE_PRESET_VALUES = ["minimal", "default", "strict", "custom"];
+var RECURRENCE_FREQUENCY_VALUES = ["daily", "weekly", "monthly", "yearly"];
+var RECURRENCE_WEEKDAY_VALUES = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+function weekdayOrderIndex(value) {
+  return RECURRENCE_WEEKDAY_VALUES.indexOf(value);
+}
+var PLAN_MODE_VALUES = [
+  "draft",
+  "research",
+  "review",
+  "approved",
+  "executing",
+  "paused",
+  "completed",
+  "superseded"
+];
+var PLAN_STEP_STATUS_VALUES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "skipped",
+  "superseded"
+];
+var PLAN_HARNESS_VALUES = ["codex", "claude-code", "cursor", "generic"];
+var PLAN_STEP_LINK_KIND_VALUES = [
+  "related",
+  "blocks",
+  "blocked_by",
+  "depends_on",
+  "discovered_from",
+  "implements",
+  "verifies",
+  "supersedes"
+];
+var CONTEXT_DEPTH_VALUES = ["brief", "standard", "deep", "full"];
+var CONTEXT_SECTION_VALUES = [
+  "hierarchy",
+  "activity",
+  "progress",
+  "recently_created",
+  "unparented",
+  "blockers",
+  "files",
+  "workload",
+  "staleness",
+  "tests"
+];
+
+// dist/types/index.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] = "c57bc662-d60a-54b1-b2da-a7d9d7fde67a");
+  } catch (e2) {
+  }
+})();
+
+// dist/core/item/item-type-definition.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] = "257435ee-2ef3-5736-a403-57d6265cf280");
+  } catch (e2) {
+  }
+})();
+function normalizeItemTypeStringList(values) {
+  return [...new Set((values ?? []).map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function normalizeItemTypeOption(option) {
+  const key = option.key.trim();
+  if (key.length === 0) {
+    return null;
+  }
+  const aliases = normalizeItemTypeStringList(option.aliases);
+  const description = option.description?.trim();
+  return {
+    key,
+    values: normalizeItemTypeStringList(option.values),
+    required: option.required === true ? true : void 0,
+    aliases: aliases.length > 0 ? aliases : void 0,
+    description: description && description.length > 0 ? description : void 0
+  };
+}
+var keepPolicyCommand = (command) => command;
+var strictPolicyCommand = (command) => {
+  const normalized = command.trim().toLowerCase();
+  return normalized === "create" || normalized === "update" ? normalized : null;
+};
+function normalizeItemTypeCommandOptionPolicy(policy, resolvePolicyCommand) {
+  const command = resolvePolicyCommand(policy.command);
+  if (command === null) {
+    return null;
+  }
+  const option = policy.option.trim();
+  if (option.length === 0) {
+    return null;
+  }
+  return {
+    command,
+    option,
+    required: policy.required,
+    visible: policy.visible,
+    enabled: policy.enabled
+  };
+}
+function normalizeItemTypeCommandOptionPolicies(policies, resolvePolicyCommand) {
+  const dedupedByKey = /* @__PURE__ */ new Map();
+  for (const policy of policies ?? []) {
+    const normalized = normalizeItemTypeCommandOptionPolicy(policy, resolvePolicyCommand);
+    if (!normalized) {
+      continue;
+    }
+    dedupedByKey.set(`${normalized.command}:${normalized.option.toLowerCase()}`, normalized);
+  }
+  return [...dedupedByKey.values()].sort((left, right) => left.command === right.command ? left.option.localeCompare(right.option) : left.command.localeCompare(right.command));
+}
+function normalizeItemTypeDefinition(definition, options = {}) {
+  const resolvePolicyCommand = options.resolvePolicyCommand ?? keepPolicyCommand;
+  const name = definition.name.trim();
+  if (name.length === 0) {
+    return null;
+  }
+  const hasRequiredCreateFields = definition.required_create_fields !== void 0;
+  const hasRequiredCreateRepeatables = definition.required_create_repeatables !== void 0;
+  const hasOptions = definition.options !== void 0;
+  const hasCommandOptionPolicies = definition.command_option_policies !== void 0;
+  const folder = definition.folder?.trim();
+  const description = definition.description?.trim();
+  const defaultStatus = definition.default_status?.trim();
+  const aliases = normalizeItemTypeStringList(definition.aliases);
+  const normalizedOptions = (definition.options ?? []).map((option) => normalizeItemTypeOption(option)).filter((option) => option !== null).sort((left, right) => left.key.localeCompare(right.key));
+  const commandOptionPolicies = normalizeItemTypeCommandOptionPolicies(definition.command_option_policies, resolvePolicyCommand);
+  return {
+    name,
+    description: description && description.length > 0 ? description : void 0,
+    default_status: defaultStatus && defaultStatus.length > 0 ? defaultStatus : void 0,
+    folder: folder && folder.length > 0 ? folder : void 0,
+    aliases: aliases.length > 0 ? aliases : void 0,
+    required_create_fields: hasRequiredCreateFields ? normalizeItemTypeStringList(definition.required_create_fields) : void 0,
+    required_create_repeatables: hasRequiredCreateRepeatables ? normalizeItemTypeStringList(definition.required_create_repeatables) : void 0,
+    options: hasOptions ? normalizedOptions : void 0,
+    command_option_policies: hasCommandOptionPolicies ? commandOptionPolicies : void 0
+  };
+}
+
+// dist/core/item/type-registry.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] = "aca609de-d881-5f34-804f-ed3daa6aab2a");
+  } catch (e2) {
+  }
+})();
+var DEFAULT_REQUIRED_CREATE_FIELDS = [
+  "title",
+  "description",
+  "status",
+  "priority",
+  "tags",
+  "body",
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "author",
+  "message",
+  "assignee"
+];
+var DEFAULT_REQUIRED_CREATE_REPEATABLES = ["dep", "comment", "note", "learning", "file", "test", "doc"];
+var COMMON_MUTATION_COMMAND_OPTION_KEYS = [
+  "deadline",
+  "estimatedMinutes",
+  "acceptanceCriteria",
+  "definitionOfReady",
+  "order",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "whyNow",
+  "assignee",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blockedBy",
+  "blockedReason",
+  "unblockNote",
+  "reporter",
+  "severity",
+  "environment",
+  "reproSteps",
+  "resolution",
+  "expectedResult",
+  "actualResult",
+  "affectedVersion",
+  "fixedVersion",
+  "component",
+  "regression",
+  "customerImpact"
+];
+var CREATE_COMMAND_OPTION_KEYS = [
+  "title",
+  "description",
+  "type",
+  "status",
+  "priority",
+  "tags",
+  "body",
+  ...COMMON_MUTATION_COMMAND_OPTION_KEYS,
+  "author",
+  "message",
+  "dep",
+  "comment",
+  "note",
+  "learning",
+  "file",
+  "test",
+  "doc",
+  "reminder",
+  "event",
+  "typeOption",
+  "field"
+];
+var UPDATE_COMMAND_OPTION_KEYS = [
+  "title",
+  "description",
+  "body",
+  "status",
+  "closeReason",
+  "priority",
+  "type",
+  "tags",
+  ...COMMON_MUTATION_COMMAND_OPTION_KEYS,
+  "author",
+  "message",
+  "comment",
+  "note",
+  "learning",
+  "file",
+  "test",
+  "doc",
+  "reminder",
+  "event",
+  "typeOption",
+  "field",
+  "allowAuditUpdate",
+  "force"
+];
+var SHARED_COMMAND_OPTION_ALIASES = {
+  "close-reason": "closeReason",
+  close_reason: "closeReason",
+  "estimated-minutes": "estimatedMinutes",
+  estimated_minutes: "estimatedMinutes",
+  estimate: "estimatedMinutes",
+  "acceptance-criteria": "acceptanceCriteria",
+  acceptance_criteria: "acceptanceCriteria",
+  ac: "acceptanceCriteria",
+  "definition-of-ready": "definitionOfReady",
+  definition_of_ready: "definitionOfReady",
+  rank: "order",
+  "why-now": "whyNow",
+  why_now: "whyNow",
+  "blocked-by": "blockedBy",
+  blocked_by: "blockedBy",
+  "blocked-reason": "blockedReason",
+  blocked_reason: "blockedReason",
+  "unblock-note": "unblockNote",
+  unblock_note: "unblockNote",
+  "repro-steps": "reproSteps",
+  repro_steps: "reproSteps",
+  "expected-result": "expectedResult",
+  expected_result: "expectedResult",
+  "actual-result": "actualResult",
+  actual_result: "actualResult",
+  "affected-version": "affectedVersion",
+  affected_version: "affectedVersion",
+  "fixed-version": "fixedVersion",
+  fixed_version: "fixedVersion",
+  "customer-impact": "customerImpact",
+  customer_impact: "customerImpact",
+  "type-option": "typeOption",
+  type_option: "typeOption",
+  type_options: "typeOption"
+};
+var CREATE_COMMAND_OPTION_ALIASES = {
+  ...SHARED_COMMAND_OPTION_ALIASES
+};
+var UPDATE_COMMAND_OPTION_ALIASES = {
+  ...SHARED_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"
+};
+function normalizeCommandOptionToken(value) {
+  return value.trim().replace(/^--+/, "").toLowerCase();
+}
+function commandOptionKeys(command) {
+  return command === "create" ? CREATE_COMMAND_OPTION_KEYS : UPDATE_COMMAND_OPTION_KEYS;
+}
+function commandOptionAliases(command) {
+  return command === "create" ? CREATE_COMMAND_OPTION_ALIASES : UPDATE_COMMAND_OPTION_ALIASES;
+}
+function canonicalizeCommandOptionKey(command, rawOption) {
+  const normalizedToken = normalizeCommandOptionToken(rawOption);
+  if (normalizedToken.length === 0) {
+    return void 0;
+  }
+  const aliased = commandOptionAliases(command)[normalizedToken];
+  if (aliased) {
+    return aliased;
+  }
+  return commandOptionKeys(command).find((candidate) => candidate.toLowerCase() === normalizedToken);
+}
+function commandOptionFlagLabel(command, optionKey) {
+  const labels = command === "create" ? CREATE_COMMAND_OPTION_FLAG_LABELS : UPDATE_COMMAND_OPTION_FLAG_LABELS;
+  return labels[optionKey] ?? `--${optionKey.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+}
+function toDefaultFolder(name) {
+  const normalized = toSlugToken(name);
+  if (normalized.length === 0) {
+    return "items";
+  }
+  return normalized.endsWith("s") ? normalized : `${normalized}s`;
+}
+function toSlugToken(value) {
+  const trimmed = value.trim().toLowerCase();
+  let slug = "";
+  let pendingDash = false;
+  for (const character of trimmed) {
+    const code = character.charCodeAt(0);
+    const isAlpha = code >= 97 && code <= 122;
+    const isDigit = code >= 48 && code <= 57;
+    if (isAlpha || isDigit) {
+      if (pendingDash && slug.length > 0) {
+        slug += "-";
+      }
+      slug += character;
+      pendingDash = false;
+      continue;
+    }
+    if (slug.length > 0) {
+      pendingDash = true;
+    }
+  }
+  return slug;
+}
+function normalizeTypeDefinition(definition) {
+  return normalizeItemTypeDefinition(definition, { resolvePolicyCommand: strictPolicyCommand });
+}
+function coerceTypeDefinitionFromUnknown(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return null;
+  }
+  const record = raw;
+  const name = typeof record.name === "string" ? record.name : "";
+  if (name.trim().length === 0) {
+    return null;
+  }
+  const folder = typeof record.folder === "string" ? record.folder : void 0;
+  const description = typeof record.description === "string" ? record.description : void 0;
+  const defaultStatus = typeof record.default_status === "string" ? record.default_status : void 0;
+  const aliases = Array.isArray(record.aliases) ? record.aliases.filter((value) => typeof value === "string") : void 0;
+  const requiredCreateFields = Array.isArray(record.required_create_fields) ? record.required_create_fields.filter((value) => typeof value === "string") : void 0;
+  const requiredCreateRepeatables = Array.isArray(record.required_create_repeatables) ? record.required_create_repeatables.filter((value) => typeof value === "string") : void 0;
+  let options;
+  if (Array.isArray(record.options)) {
+    options = [];
+    for (const entry of record.options) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        continue;
+      }
+      const optionRecord = entry;
+      if (typeof optionRecord.key !== "string") {
+        continue;
+      }
+      options.push({
+        key: optionRecord.key,
+        values: Array.isArray(optionRecord.values) ? optionRecord.values.filter((value) => typeof value === "string") : [],
+        required: optionRecord.required === void 0 ? void 0 : Boolean(optionRecord.required),
+        aliases: Array.isArray(optionRecord.aliases) ? optionRecord.aliases.filter((value) => typeof value === "string") : void 0,
+        description: typeof optionRecord.description === "string" ? optionRecord.description : void 0
+      });
+    }
+  }
+  let commandOptionPolicies;
+  if (Array.isArray(record.command_option_policies)) {
+    commandOptionPolicies = [];
+    for (const entry of record.command_option_policies) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        continue;
+      }
+      const policyRecord = entry;
+      if (typeof policyRecord.command !== "string" || typeof policyRecord.option !== "string") {
+        continue;
+      }
+      const normalizedCommand = policyRecord.command.trim().toLowerCase();
+      if (normalizedCommand !== "create" && normalizedCommand !== "update") {
+        continue;
+      }
+      commandOptionPolicies.push({
+        command: normalizedCommand,
+        option: policyRecord.option,
+        required: policyRecord.required === void 0 ? void 0 : Boolean(policyRecord.required),
+        visible: policyRecord.visible === void 0 ? void 0 : Boolean(policyRecord.visible),
+        enabled: policyRecord.enabled === void 0 ? void 0 : Boolean(policyRecord.enabled)
+      });
+    }
+  }
+  return {
+    name,
+    description,
+    default_status: defaultStatus,
+    folder,
+    aliases,
+    required_create_fields: requiredCreateFields,
+    required_create_repeatables: requiredCreateRepeatables,
+    options,
+    command_option_policies: commandOptionPolicies
+  };
+}
+function applyTypeDefinitions(source, target) {
+  for (const rawDefinition of source) {
+    const normalizedDefinition = normalizeTypeDefinition(rawDefinition);
+    if (!normalizedDefinition) {
+      continue;
+    }
+    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 requiredCreateFields = normalizedDefinition.required_create_fields ? normalizeItemTypeStringList(normalizedDefinition.required_create_fields) : existing?.required_create_fields ?? [];
+    const requiredCreateRepeatables = normalizedDefinition.required_create_repeatables ? normalizeItemTypeStringList(normalizedDefinition.required_create_repeatables) : existing?.required_create_repeatables ?? [];
+    const options = normalizedDefinition.options ? normalizedDefinition.options : existing?.options ? [...existing.options] : [];
+    const commandOptionPolicies = normalizedDefinition.command_option_policies ? normalizedDefinition.command_option_policies : existing?.command_option_policies ? [...existing.command_option_policies] : [];
+    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: requiredCreateFields,
+      required_create_repeatables: requiredCreateRepeatables,
+      options,
+      command_option_policies: commandOptionPolicies
+    });
+  }
+}
+function collectExtensionTypeDefinitions(registrations) {
+  if (!registrations) {
+    return [];
+  }
+  const definitions = [];
+  for (const registration of registrations.item_types ?? []) {
+    const typeDefinitionsRaw = registration.types;
+    if (!Array.isArray(typeDefinitionsRaw)) {
+      continue;
+    }
+    for (const rawDefinition of typeDefinitionsRaw) {
+      const normalized = coerceTypeDefinitionFromUnknown(rawDefinition);
+      if (normalized) {
+        definitions.push(normalized);
+      }
+    }
+  }
+  return definitions;
+}
+function resolveItemTypeRegistry(settings, extensionRegistrations = null) {
+  const byLowerName = /* @__PURE__ */ new Map();
+  for (const builtin of ITEM_TYPE_VALUES) {
+    byLowerName.set(builtin.toLowerCase(), {
+      name: builtin,
+      folder: TYPE_TO_FOLDER[builtin],
+      aliases: [],
+      required_create_fields: [...DEFAULT_REQUIRED_CREATE_FIELDS],
+      required_create_repeatables: [...DEFAULT_REQUIRED_CREATE_REPEATABLES],
+      options: [],
+      command_option_policies: []
+    });
+  }
+  applyTypeDefinitions(settings.item_types?.definitions ?? [], byLowerName);
+  applyTypeDefinitions(collectExtensionTypeDefinitions(extensionRegistrations), byLowerName);
+  const definitions = [...byLowerName.values()].sort((left, right) => left.name.localeCompare(right.name));
+  const byType = {};
+  const aliasToType = {};
+  const typeToFolder = {};
+  for (const definition of definitions) {
+    byType[definition.name] = definition;
+    typeToFolder[definition.name] = definition.folder;
+    aliasToType[definition.name.toLowerCase()] = definition.name;
+    for (const alias of definition.aliases) {
+      aliasToType[alias.toLowerCase()] = definition.name;
+    }
+  }
+  const folders = [...new Set(definitions.map((definition) => definition.folder))].sort((left, right) => left.localeCompare(right));
+  return {
+    types: definitions.map((definition) => definition.name),
+    folders,
+    type_to_folder: typeToFolder,
+    by_type: byType,
+    alias_to_type: aliasToType
+  };
+}
+function resolveTypeName(rawType, registry) {
+  if (rawType === void 0) {
+    return void 0;
+  }
+  return registry.alias_to_type[rawType.trim().toLowerCase()];
+}
+function resolveTypeDefinition(typeName, registry) {
+  const resolvedName = resolveTypeName(typeName, registry);
+  if (!resolvedName) {
+    return void 0;
+  }
+  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();
+  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}"`);
+      continue;
+    }
+    required.add(canonical);
+  }
+  for (const policy of typeDefinition.command_option_policies) {
+    if (policy.command !== command) {
+      continue;
     }
-  },
-  context: {
-    default_depth: "brief",
-    activity_limit: 10,
-    stale_threshold_days: 7,
-    sections: {
-      hierarchy: true,
-      activity: true,
-      progress: true,
-      recently_created: true,
-      unparented: true,
-      blockers: true,
-      files: true,
-      workload: true,
-      staleness: true,
-      tests: true
+    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;
     }
-  },
-  vector_store: {
-    adapter: "",
-    collection_name: "pm_items",
-    qdrant: {
-      url: "",
-      api_key: ""
-    },
-    lancedb: {
-      path: ""
+    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);
+      }
     }
   }
-};
-var EMPTY_CANONICAL_DOCUMENT = {
-  metadata: {},
-  body: ""
-};
-var EXIT_CODE = {
-  SUCCESS: 0,
-  GENERIC_FAILURE: 1,
-  USAGE: 2,
-  NOT_FOUND: 3,
-  CONFLICT: 4,
-  DEPENDENCY_FAILED: 5
-};
-var TELEMETRY_ERROR_CATEGORY_BY_CODE = Object.freeze({
-  unknown_command: "usage",
-  unknown_option: "usage",
-  missing_required_option: "usage",
-  missing_required_argument: "usage",
-  invalid_command_usage: "usage",
-  linked_test_value_not_quoted: "usage",
-  invalid_argument_value: "validation",
-  health_findings: "validation",
-  validation_findings: "validation",
-  close_through_update: "validation",
-  no_update_fields: "validation",
-  unsupported_update_option: "validation",
-  tracker_not_initialized: "validation",
-  item_not_found: "validation",
-  ownership_conflict: "conflict",
-  lock_conflict: "conflict",
-  terminal_state_conflict: "conflict",
-  dependency_failed: "runtime",
-  command_failed: "runtime",
-  unknown_error: "runtime"
-});
-function resolveTelemetryErrorCategory(errorCode) {
-  const normalized = (errorCode ?? "").trim().toLowerCase();
-  if (normalized.length === 0) {
-    return "unknown";
+  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}"`);
+    }
   }
-  const explicit = TELEMETRY_ERROR_CATEGORY_BY_CODE[normalized];
-  if (typeof explicit === "string") {
-    return explicit;
+  return {
+    required: [...required],
+    hidden: [...hidden].sort((left, right) => left.localeCompare(right)),
+    disabled: [...disabled].sort((left, right) => left.localeCompare(right)),
+    errors
+  };
+}
+function validateTypeOptions(typeName, rawTypeOptions, registry) {
+  const typeDefinition = resolveTypeDefinition(typeName, registry);
+  if (!typeDefinition) {
+    return {
+      normalized: void 0,
+      errors: [`Unknown type "${typeName}"`]
+    };
   }
-  if (normalized.includes("conflict") || normalized.includes("locked")) {
-    return "conflict";
+  const errors = [];
+  const optionByAlias = /* @__PURE__ */ new Map();
+  for (const option of typeDefinition.options) {
+    optionByAlias.set(option.key.toLowerCase(), option);
+    for (const alias of option.aliases ?? []) {
+      optionByAlias.set(alias.toLowerCase(), option);
+    }
   }
-  if (normalized.startsWith("unknown_") || normalized.startsWith("missing_required_")) {
-    return "usage";
+  const normalized = {};
+  for (const [rawKey, rawValue] of Object.entries(rawTypeOptions ?? {})) {
+    const trimmedKey = rawKey.trim();
+    const trimmedValue = rawValue.trim();
+    if (trimmedKey.length === 0) {
+      errors.push("type option keys must not be empty");
+      continue;
+    }
+    if (trimmedValue.length === 0) {
+      errors.push(`type option "${trimmedKey}" must not be empty`);
+      continue;
+    }
+    const optionDefinition = optionByAlias.get(trimmedKey.toLowerCase());
+    if (!optionDefinition) {
+      const allowed = typeDefinition.options.map((option) => option.key).join(", ");
+      errors.push(typeDefinition.options.length > 0 ? `Unknown type option "${trimmedKey}" for type "${typeDefinition.name}". Allowed: ${allowed}` : `Type "${typeDefinition.name}" does not define any configurable type options`);
+      continue;
+    }
+    const allowedValues = optionDefinition.values;
+    let resolvedValue = trimmedValue;
+    if (allowedValues.length > 0) {
+      const valueLookup = new Map(allowedValues.map((value) => [value.toLowerCase(), value]));
+      const canonical = valueLookup.get(trimmedValue.toLowerCase());
+      if (!canonical) {
+        errors.push(`Invalid value "${trimmedValue}" for type option "${optionDefinition.key}". Allowed: ${allowedValues.join(", ")}`);
+        continue;
+      }
+      resolvedValue = canonical;
+    }
+    normalized[optionDefinition.key] = resolvedValue;
   }
-  if (normalized.startsWith("invalid_") || normalized.endsWith("_not_found") || normalized.includes("validation")) {
-    return "validation";
+  for (const option of typeDefinition.options) {
+    if (option.required && !(option.key in normalized)) {
+      errors.push(`Missing required type option "${option.key}" for type "${typeDefinition.name}"`);
+    }
   }
-  if (normalized.endsWith("_error") || normalized.endsWith("_failed")) {
-    return "runtime";
+  const sortedKeys = Object.keys(normalized).sort((left, right) => left.localeCompare(right));
+  if (sortedKeys.length === 0) {
+    return {
+      normalized: void 0,
+      errors
+    };
   }
-  return "unknown";
+  return {
+    normalized: Object.fromEntries(sortedKeys.map((key) => [key, normalized[key]])),
+    errors
+  };
 }
 
 // dist/core/store/paths.js
@@ -648,7 +1488,7 @@ import path4 from "node:path";
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "7e5cc2a5-f199-5629-b251-a0e9df176341");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d46f24c7-aad0-58e5-b27e-ce9388964d8a");
   } catch (e2) {
   }
 })();
@@ -712,37 +1552,8 @@ function resolveGlobalPmRoot(cwd) {
 function getSettingsPath(pmRoot) {
   return path4.join(pmRoot, SETTINGS_FILENAME);
 }
-function deriveDefaultTypeFolder(type) {
-  const normalized = toSlugToken(type);
-  if (normalized.length === 0) {
-    return "items";
-  }
-  return normalized.endsWith("s") ? normalized : `${normalized}s`;
-}
-function toSlugToken(value) {
-  const trimmed = value.trim().toLowerCase();
-  let slug = "";
-  let pendingDash = false;
-  for (const character of trimmed) {
-    const code = character.charCodeAt(0);
-    const isAlpha = code >= 97 && code <= 122;
-    const isDigit = code >= 48 && code <= 57;
-    if (isAlpha || isDigit) {
-      if (pendingDash && slug.length > 0) {
-        slug += "-";
-      }
-      slug += character;
-      pendingDash = false;
-      continue;
-    }
-    if (slug.length > 0) {
-      pendingDash = true;
-    }
-  }
-  return slug;
-}
 function getTypeDirPath(pmRoot, type, typeToFolder = TYPE_TO_FOLDER) {
-  const folder = typeToFolder[type] ?? deriveDefaultTypeFolder(type);
+  const folder = typeToFolder[type] ?? toDefaultFolder(type);
   return path4.join(pmRoot, folder);
 }
 function getItemPath(pmRoot, type, id, itemFormat = "toon", typeToFolder = TYPE_TO_FOLDER) {
@@ -853,11 +1664,63 @@ function asRecordLoose(value) {
   return value;
 }
 
+// dist/core/shared/levenshtein.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] = "99ae52e7-bf5e-51ab-a222-d6ffb82027ff");
+  } catch (e2) {
+  }
+})();
+function levenshteinDistanceWithinLimit(left, right, limit) {
+  if (left === right) {
+    return 0;
+  }
+  if (Math.abs(left.length - right.length) > limit) {
+    return null;
+  }
+  const width = right.length + 1;
+  const beforePrevious = new Array(width);
+  const previous = new Array(width);
+  const current = new Array(width);
+  for (let column = 0; column < width; column += 1) {
+    beforePrevious[column] = 0;
+    previous[column] = column;
+  }
+  for (let row = 1; row <= left.length; row += 1) {
+    current[0] = row;
+    let rowMin = current[0];
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      const substitution = previous[column - 1] + cost;
+      const insertion = current[column - 1] + 1;
+      const deletion = previous[column] + 1;
+      let candidate = Math.min(substitution, insertion, deletion);
+      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+        candidate = Math.min(candidate, beforePrevious[column - 2] + 1);
+      }
+      current[column] = candidate;
+      if (candidate < rowMin) {
+        rowMin = candidate;
+      }
+    }
+    if (rowMin > limit) {
+      return null;
+    }
+    for (let column = 0; column < width; column += 1) {
+      beforePrevious[column] = previous[column];
+      previous[column] = current[column];
+    }
+  }
+  const result = previous[right.length];
+  return result <= limit ? result : null;
+}
+
 // dist/core/extensions/extension-registries.js
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "2520e0b0-3e9e-5f16-93a0-c0e45fc8bb8f");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "dcfdfd88-3d2a-57c9-9873-d8d7d9cf339d");
   } catch (e2) {
   }
 })();
@@ -903,6 +1766,7 @@ function createEmptyExtensionRegistrationRegistry() {
     item_fields: [],
     item_types: [],
     migrations: [],
+    profiles: [],
     importers: [],
     exporters: [],
     search_providers: [],
@@ -1401,59 +2265,7 @@ function isFlagDefaultValueCoercible(value, kind) {
   if (typeof value === "boolean") {
     return true;
   }
-  return typeof value === "string" && ["true", "false", "1", "0"].includes(value.trim().toLowerCase());
-}
-
-// dist/core/shared/levenshtein.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] = "99ae52e7-bf5e-51ab-a222-d6ffb82027ff");
-  } catch (e2) {
-  }
-})();
-function levenshteinDistanceWithinLimit(left, right, limit) {
-  if (left === right) {
-    return 0;
-  }
-  if (Math.abs(left.length - right.length) > limit) {
-    return null;
-  }
-  const width = right.length + 1;
-  const beforePrevious = new Array(width);
-  const previous = new Array(width);
-  const current = new Array(width);
-  for (let column = 0; column < width; column += 1) {
-    beforePrevious[column] = 0;
-    previous[column] = column;
-  }
-  for (let row = 1; row <= left.length; row += 1) {
-    current[0] = row;
-    let rowMin = current[0];
-    for (let column = 1; column <= right.length; column += 1) {
-      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
-      const substitution = previous[column - 1] + cost;
-      const insertion = current[column - 1] + 1;
-      const deletion = previous[column] + 1;
-      let candidate = Math.min(substitution, insertion, deletion);
-      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
-        candidate = Math.min(candidate, beforePrevious[column - 2] + 1);
-      }
-      current[column] = candidate;
-      if (candidate < rowMin) {
-        rowMin = candidate;
-      }
-    }
-    if (rowMin > limit) {
-      return null;
-    }
-    for (let column = 0; column < width; column += 1) {
-      beforePrevious[column] = previous[column];
-      previous[column] = current[column];
-    }
-  }
-  const result = previous[right.length];
-  return result <= limit ? result : null;
+  return typeof value === "string" && ["true", "false", "1", "0"].includes(value.trim().toLowerCase());
 }
 
 // dist/core/extensions/item-field-types.js
@@ -1483,6 +2295,100 @@ function suggestKnownItemFieldType(value) {
   return null;
 }
 
+// dist/core/extensions/version-compat.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] = "9675b93b-da90-574d-a6cf-ea7448b40600");
+  } catch (e2) {
+  }
+})();
+function formatVersionBoundValue(value) {
+  return typeof value === "string" ? value : String(value);
+}
+function parseComparableVersion(value) {
+  const normalized = value.trim().replace(/^>=\s*/, "").replace(/^v/i, "");
+  const release = normalized.split(/[+-]/, 1)[0];
+  if (!/^\d+(?:[.-]\d+)*$/.test(release)) {
+    return null;
+  }
+  return release.split(/[.-]/).map((part) => Number(part));
+}
+function compareComparableVersions(currentVersion, otherVersion) {
+  const currentParts = parseComparableVersion(currentVersion);
+  const otherParts = parseComparableVersion(otherVersion);
+  if (!currentParts || !otherParts) {
+    return null;
+  }
+  const width = Math.max(currentParts.length, otherParts.length);
+  for (let index = 0; index < width; index += 1) {
+    const current = currentParts[index] ?? 0;
+    const other = otherParts[index] ?? 0;
+    if (current > other) {
+      return 1;
+    }
+    if (current < other) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function evaluatePmMinVersionBound(required, currentVersion) {
+  if (required === void 0 || required === null) {
+    return { kind: "pm_min_version", status: "absent", allowed: true, required: "", current: currentVersion };
+  }
+  const declared = formatVersionBoundValue(required);
+  if (typeof required !== "string" || declared.trim().length === 0) {
+    return { kind: "pm_min_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (!parseComparableVersion(declared)) {
+    return { kind: "pm_min_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (currentVersion === null) {
+    return { kind: "pm_min_version", status: "unchecked", allowed: true, required: declared, current: null };
+  }
+  const comparison = compareComparableVersions(currentVersion, declared);
+  if (comparison === null) {
+    return { kind: "pm_min_version", status: "unchecked", allowed: true, required: declared, current: currentVersion };
+  }
+  if (comparison < 0) {
+    return { kind: "pm_min_version", status: "unmet", allowed: false, required: declared, current: currentVersion };
+  }
+  return { kind: "pm_min_version", status: "ok", allowed: true, required: declared, current: currentVersion };
+}
+function evaluatePmMaxVersionBound(required, currentVersion, exceededMode) {
+  if (required === void 0 || required === null) {
+    return { kind: "pm_max_version", status: "absent", allowed: true, required: "", current: currentVersion };
+  }
+  const declared = formatVersionBoundValue(required);
+  if (typeof required !== "string" || declared.trim().length === 0) {
+    return { kind: "pm_max_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (/^[<>=~^]/.test(declared.trim()) || !parseComparableVersion(declared)) {
+    return { kind: "pm_max_version", status: "invalid", allowed: false, required: declared, current: currentVersion };
+  }
+  if (currentVersion === null) {
+    return { kind: "pm_max_version", status: "unchecked", allowed: true, required: declared, current: null };
+  }
+  const comparison = compareComparableVersions(currentVersion, declared);
+  if (comparison === null) {
+    return { kind: "pm_max_version", status: "unchecked", allowed: true, required: declared, current: currentVersion };
+  }
+  if (comparison > 0) {
+    if (exceededMode === "warn") {
+      return {
+        kind: "pm_max_version",
+        status: "exceeded_warn",
+        allowed: true,
+        required: declared,
+        current: currentVersion
+      };
+    }
+    return { kind: "pm_max_version", status: "exceeded", allowed: false, required: declared, current: currentVersion };
+  }
+  return { kind: "pm_max_version", status: "ok", allowed: true, required: declared, current: currentVersion };
+}
+
 // dist/core/extensions/extension-capability-aliases.js
 !(function() {
   try {
@@ -2114,7 +3020,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] = "7c9e6f67-48e5-5952-a7a7-341aafa36244");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "a323e13b-37e3-5ec6-bc21-1ab78e0b30b9");
   } catch (e2) {
   }
 })();
@@ -2613,33 +3519,6 @@ function formatUnknownError(error) {
   }
   return String(error);
 }
-function parseComparableVersion(value) {
-  const normalized = value.trim().replace(/^>=\s*/, "").replace(/^v/i, "");
-  const release = normalized.split(/[+-]/, 1)[0];
-  if (!/^\d+(?:[.-]\d+)*$/.test(release)) {
-    return null;
-  }
-  return release.split(/[.-]/).map((part) => Number(part));
-}
-function compareComparableVersions(currentVersion, minimumVersion) {
-  const currentParts = parseComparableVersion(currentVersion);
-  const minimumParts = parseComparableVersion(minimumVersion);
-  if (!currentParts || !minimumParts) {
-    return null;
-  }
-  const width = Math.max(currentParts.length, minimumParts.length);
-  for (let index = 0; index < width; index += 1) {
-    const current = currentParts[index] ?? 0;
-    const minimum = minimumParts[index] ?? 0;
-    if (current > minimum) {
-      return 1;
-    }
-    if (current < minimum) {
-      return -1;
-    }
-  }
-  return 0;
-}
 async function readCurrentPmCliVersion() {
   try {
     const packageRoot = resolvePmPackageRootFromModule(import.meta.url, ["../../.."]);
@@ -2654,81 +3533,48 @@ function resolveCurrentPmCliVersion() {
   currentPmCliVersionPromise ??= readCurrentPmCliVersion();
   return currentPmCliVersionPromise;
 }
-async function evaluatePmMinVersionCompatibility(layer, manifest) {
-  if (typeof manifest.pm_min_version !== "string" || manifest.pm_min_version.trim().length === 0) {
-    return { allowed: true };
-  }
-  if (!parseComparableVersion(manifest.pm_min_version)) {
-    return {
-      allowed: false,
-      warning: `extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${manifest.pm_min_version}`
-    };
-  }
-  const currentVersion = await resolveCurrentPmCliVersion();
-  if (!currentVersion) {
-    return {
-      allowed: true,
-      warning: `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=unknown`
-    };
+function formatPmVersionCompatibilityWarning(layer, manifest, evaluation) {
+  const current = evaluation.current ?? "unknown";
+  if (evaluation.kind === "pm_min_version") {
+    switch (evaluation.status) {
+      case "invalid":
+        return `extension_pm_min_version_invalid:${layer}:${manifest.name}:required=${evaluation.required}`;
+      case "unchecked":
+        return `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;
+      case "unmet":
+        return `extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${evaluation.required}:current=${current}`;
+      default:
+        return void 0;
+    }
   }
-  const comparison = compareComparableVersions(currentVersion, manifest.pm_min_version);
-  if (comparison === null) {
-    return {
-      allowed: true,
-      warning: `extension_pm_min_version_unchecked:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=${currentVersion}`
-    };
+  switch (evaluation.status) {
+    case "invalid":
+      return `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${evaluation.required}`;
+    case "unchecked":
+      return `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;
+    case "exceeded_warn":
+      return `extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;
+    case "exceeded":
+      return `extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${evaluation.required}:current=${current}`;
+    default:
+      return void 0;
   }
-  if (comparison < 0) {
-    return {
-      allowed: false,
-      warning: `extension_pm_min_version_unmet:${layer}:${manifest.name}:required=${manifest.pm_min_version}:current=${currentVersion}`
-    };
+}
+async function evaluatePmMinVersionCompatibility(layer, manifest) {
+  if (manifest.pm_min_version === void 0) {
+    return { allowed: true };
   }
-  return { allowed: true };
+  const evaluation = evaluatePmMinVersionBound(manifest.pm_min_version, await resolveCurrentPmCliVersion());
+  const warning = formatPmVersionCompatibilityWarning(layer, manifest, evaluation);
+  return warning ? { allowed: evaluation.allowed, warning } : { allowed: evaluation.allowed };
 }
 async function evaluatePmMaxVersionCompatibility(layer, manifest, exceededMode) {
-  if (typeof manifest.pm_max_version !== "string" || manifest.pm_max_version.trim().length === 0) {
+  if (manifest.pm_max_version === void 0) {
     return { allowed: true };
   }
-  if (/^[<>=~^]/.test(manifest.pm_max_version.trim())) {
-    return {
-      allowed: false,
-      warning: `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}`
-    };
-  }
-  if (!parseComparableVersion(manifest.pm_max_version)) {
-    return {
-      allowed: false,
-      warning: `extension_pm_max_version_invalid:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}`
-    };
-  }
-  const currentVersion = await resolveCurrentPmCliVersion();
-  if (!currentVersion) {
-    return {
-      allowed: true,
-      warning: `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=unknown`
-    };
-  }
-  const comparison = compareComparableVersions(currentVersion, manifest.pm_max_version);
-  if (comparison === null) {
-    return {
-      allowed: true,
-      warning: `extension_pm_max_version_unchecked:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
-    };
-  }
-  if (comparison > 0) {
-    if (exceededMode === "warn") {
-      return {
-        allowed: true,
-        warning: `extension_pm_max_version_exceeded_warn:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
-      };
-    }
-    return {
-      allowed: false,
-      warning: `extension_pm_max_version_exceeded:${layer}:${manifest.name}:allowed=${manifest.pm_max_version}:current=${currentVersion}`
-    };
-  }
-  return { allowed: true };
+  const evaluation = evaluatePmMaxVersionBound(manifest.pm_max_version, await resolveCurrentPmCliVersion(), exceededMode);
+  const warning = formatPmVersionCompatibilityWarning(layer, manifest, evaluation);
+  return warning ? { allowed: evaluation.allowed, warning } : { allowed: evaluation.allowed };
 }
 async function fingerprintPath(pathToInspect) {
   try {
@@ -3161,6 +4007,86 @@ function validateMigrationDefinition(definition) {
     throw new TypeError("registerMigration definition.run must be a function when provided");
   }
 }
+var PROJECT_PROFILE_DIMENSIONS = [
+  "types",
+  "statuses",
+  "fields",
+  "workflows",
+  "config",
+  "templates",
+  "packages"
+];
+function validateProjectProfileEntryShape(dimension, index, entry) {
+  const at = `registerProfile profile.${dimension}[${index}]`;
+  if (dimension === "types") {
+    if (entry.name !== void 0 && typeof entry.name !== "string") {
+      throw new TypeError(`${at}.name must be a string when provided`);
+    }
+    return;
+  }
+  if (dimension === "workflows") {
+    if (typeof entry.type !== "string") {
+      throw new TypeError(`${at}.type must be a string`);
+    }
+    if (!Array.isArray(entry.allowed_transitions)) {
+      throw new TypeError(`${at}.allowed_transitions must be an array`);
+    }
+    for (const [pairIndex, pair] of entry.allowed_transitions.entries()) {
+      if (!Array.isArray(pair)) {
+        throw new TypeError(`${at}.allowed_transitions[${pairIndex}] must be a [from, to] array`);
+      }
+    }
+    return;
+  }
+  if (dimension === "templates") {
+    if (typeof entry.name !== "string") {
+      throw new TypeError(`${at}.name must be a string`);
+    }
+    if (typeof entry.options !== "object" || entry.options === null || Array.isArray(entry.options)) {
+      throw new TypeError(`${at}.options must be an object`);
+    }
+    return;
+  }
+  if (dimension === "packages") {
+    if (typeof entry.spec !== "string") {
+      throw new TypeError(`${at}.spec must be a string`);
+    }
+  }
+}
+function validateProjectProfileDefinition(profile) {
+  const record = asRegistrationRecord("registerProfile profile", profile);
+  assertNonEmptyString("registerProfile profile.name", record.name);
+  assertNonEmptyString("registerProfile profile.title", record.title);
+  if (record.summary !== void 0 && typeof record.summary !== "string") {
+    throw new TypeError("registerProfile profile.summary must be a string when provided");
+  }
+  for (const dimension of PROJECT_PROFILE_DIMENSIONS) {
+    const value = record[dimension];
+    if (value === void 0) {
+      continue;
+    }
+    if (!Array.isArray(value)) {
+      throw new TypeError(`registerProfile profile.${dimension} must be an array when provided`);
+    }
+    for (const [index, entry] of value.entries()) {
+      if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        throw new TypeError(`registerProfile profile.${dimension}[${index}] must be an object`);
+      }
+      validateProjectProfileEntryShape(dimension, index, entry);
+    }
+  }
+}
+function applyProjectProfileDefaults(profile) {
+  if (profile.summary === void 0) {
+    profile.summary = "";
+  }
+  for (const dimension of PROJECT_PROFILE_DIMENSIONS) {
+    if (profile[dimension] === void 0) {
+      profile[dimension] = [];
+    }
+  }
+  return profile;
+}
 function attachRuntimeDefinition(entry, runtimeDefinition) {
   Object.defineProperty(entry, "runtime_definition", {
     value: runtimeDefinition,
@@ -3462,6 +4388,19 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       definition: normalizeRegistrationRecord("registerMigration definition", definition)
     }, runtimeDefinition));
   };
+  const registerProfile = (profile) => {
+    assertExtensionCapability(extension, "schema", "registerProfile");
+    if (!allowRegistration("schema.profiles", "registerProfile", "schema")) {
+      return;
+    }
+    const snapshot = cloneRuntimeRegistrationValue(profile);
+    validateProjectProfileDefinition(snapshot);
+    registrations.profiles.push({
+      layer: extension.layer,
+      name: extension.name,
+      profile: applyProjectProfileDefaults(snapshot)
+    });
+  };
   const applyImportExportCommandMetadata = (method, commandPath, options) => {
     if (options === void 0) {
       return;
@@ -3660,6 +4599,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     registerItemFields,
     registerItemTypes,
     registerMigration,
+    registerProfile,
     registerRenderer,
     registerImporter,
     registerExporter,
@@ -3685,6 +4625,7 @@ function getRegistrationCounts(registrations) {
     item_fields: itemFieldCount,
     item_types: itemTypeCount,
     migrations: registrations.migrations.length,
+    profiles: registrations.profiles.length,
     importers: registrations.importers.length,
     exporters: registrations.exporters.length,
     search_providers: registrations.search_providers.length,
@@ -3869,7 +4810,7 @@ async function activateExtensions(loadResult) {
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f6134b79-a7d0-57d9-b25a-8e3e7b4af416");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "7cc05bac-f673-59a1-9d51-64361cf5a939");
   } catch (e2) {
   }
 })();
@@ -3917,6 +4858,7 @@ function attributeCapabilityUsage(activation) {
   record(registrations.item_fields, "schema");
   record(registrations.item_types, "schema");
   record(registrations.migrations, "schema");
+  record(registrations.profiles, "schema");
   record(registrations.importers, "importers");
   record(registrations.exporters, "importers");
   record(registrations.search_providers, "search");
@@ -4180,163 +5122,42 @@ function runActiveRendererOverride(format, 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/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] = "46812059-b93e-5599-a222-4ac0de6f4911");
-  } catch (e2) {
-  }
-})();
-var BUILTIN_ITEM_TYPE_VALUES = [
-  "Epic",
-  "Feature",
-  "Task",
-  "Chore",
-  "Issue",
-  "Decision",
-  "Event",
-  "Reminder",
-  "Milestone",
-  "Meeting",
-  "Plan"
-];
-var ITEM_TYPE_VALUES = BUILTIN_ITEM_TYPE_VALUES;
-var STATUS_VALUES = [
-  "draft",
-  "open",
-  "in_progress",
-  "blocked",
-  "closed",
-  "canceled"
-];
-var RUNTIME_STATUS_ROLE_VALUES = [
-  "draft",
-  "active",
-  "blocked",
-  "terminal",
-  "terminal_done",
-  "terminal_canceled",
-  "default_open",
-  "default_close",
-  "default_cancel"
-];
-var RUNTIME_FIELD_TYPE_VALUES = ["string", "number", "boolean", "string_array"];
-var RUNTIME_FIELD_COMMAND_VALUES = ["create", "update", "update_many", "list", "search", "calendar", "context"];
-var RUNTIME_UNKNOWN_FIELD_POLICY_VALUES = ["allow", "warn", "reject"];
-var DEPENDENCY_KIND_VALUES = [
-  "blocks",
-  "parent",
-  "child",
-  "parent_child",
-  "child_of",
-  "related",
-  "related_to",
-  "discovered_from",
-  "blocked_by",
-  "incident_from",
-  "epic",
-  "supersedes",
-  "task"
-];
-var SCOPE_VALUES = ["project", "global"];
-var RISK_VALUES = ["low", "medium", "high", "critical"];
-var ISSUE_SEVERITY_VALUES = ["low", "medium", "high", "critical"];
-var CONFIDENCE_TEXT_VALUES = ["low", "medium", "high"];
-var GOVERNANCE_PRESET_VALUES = ["minimal", "default", "strict", "custom"];
-var RECURRENCE_FREQUENCY_VALUES = ["daily", "weekly", "monthly", "yearly"];
-var RECURRENCE_WEEKDAY_VALUES = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
-function weekdayOrderIndex(value) {
-  return RECURRENCE_WEEKDAY_VALUES.indexOf(value);
+    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
+  };
 }
-var PLAN_MODE_VALUES = [
-  "draft",
-  "research",
-  "review",
-  "approved",
-  "executing",
-  "paused",
-  "completed",
-  "superseded"
-];
-var PLAN_STEP_STATUS_VALUES = [
-  "pending",
-  "in_progress",
-  "completed",
-  "blocked",
-  "skipped",
-  "superseded"
-];
-var PLAN_HARNESS_VALUES = ["codex", "claude-code", "cursor", "generic"];
-var PLAN_STEP_LINK_KIND_VALUES = [
-  "related",
-  "blocks",
-  "blocked_by",
-  "depends_on",
-  "discovered_from",
-  "implements",
-  "verifies",
-  "supersedes"
-];
-var CONTEXT_DEPTH_VALUES = ["brief", "standard", "deep", "full"];
-var CONTEXT_SECTION_VALUES = [
-  "hierarchy",
-  "activity",
-  "progress",
-  "recently_created",
-  "unparented",
-  "blockers",
-  "files",
-  "workload",
-  "staleness",
-  "tests"
-];
-
-// dist/types/index.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] = "c57bc662-d60a-54b1-b2da-a7d9d7fde67a");
-  } catch (e2) {
+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] = "c2d4d36f-68de-588d-82d7-a9265fc434ba");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d3baeeb6-0912-515f-95c1-735d3849fed4");
   } catch (e2) {
   }
 })();
@@ -4495,7 +5316,7 @@ function normalizeRuntimeFieldDefinition(definition) {
 function normalizeRuntimeSchemaSettings(schema) {
   const files = {
     ...DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
-    ...schema?.files ?? {}
+    ...schema?.files
   };
   const statusesSource = schema?.statuses && schema.statuses.length > 0 ? schema.statuses : DEFAULT_RUNTIME_STATUS_DEFINITIONS;
   const normalizedStatuses = (() => {
@@ -4760,7 +5581,7 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
     fields: [...normalizedSchema.fields, ...loadedFields ?? []],
     workflow: {
       ...normalizedSchema.workflow,
-      ...loadedWorkflow ?? {}
+      ...loadedWorkflow
     },
     type_workflows: [...normalizedSchema.type_workflows ?? [], ...loadedTypeWorkflows ?? []]
   });
@@ -4922,7 +5743,7 @@ 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] = "99f2fe3b-ac31-5e50-a687-cc8517987abe");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "bb00ffab-139c-512c-ac1f-2535f77a1f86");
   } catch (e2) {
   }
 })();
@@ -4972,74 +5793,73 @@ function sortObjectKeys(value) {
 function stableStringify(value) {
   return JSON.stringify(sortObjectKeys(value));
 }
-function stableValueEquals(left, right) {
-  if (Object.is(left, right)) {
-    return true;
+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;
+    }
   }
-  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
-    return false;
+  return false;
+}
+function compareRegExpValues(left, right) {
+  if (!(left instanceof RegExp || right instanceof RegExp)) {
+    return void 0;
   }
-  if (left instanceof RegExp || right instanceof RegExp) {
-    return left instanceof RegExp && right instanceof RegExp && left.toString() === right.toString();
+  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;
   }
-  if (left instanceof Date || right instanceof Date) {
-    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+  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) {
-    if (!(left instanceof Set && right instanceof Set) || left.size !== right.size) {
-      return false;
-    }
-    const rightValues = [...right];
-    const matched = /* @__PURE__ */ new Set();
-    for (const leftValue of left) {
-      let found = false;
-      for (let index = 0; index < rightValues.length; index += 1) {
-        if (matched.has(index)) {
-          continue;
-        }
-        if (stableValueEquals(leftValue, rightValues[index])) {
-          matched.add(index);
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        return false;
-      }
-    }
-    return true;
+  if (!(left instanceof Set && right instanceof Set) || left.size !== right.size) {
+    return false;
   }
-  if (left instanceof Map || right instanceof Map) {
-    if (!(left instanceof Map && right instanceof Map) || left.size !== right.size) {
+  const rightValues = [...right];
+  const matched = /* @__PURE__ */ new Set();
+  for (const leftValue of left) {
+    if (!hasUnmatchedEquivalent(leftValue, rightValues, matched, stableValueEquals)) {
       return false;
     }
-    const rightEntries = [...right.entries()];
-    const matched = /* @__PURE__ */ new Set();
-    for (const [leftKey, leftValue] of left.entries()) {
-      let found = false;
-      for (let index = 0; index < rightEntries.length; index += 1) {
-        if (matched.has(index)) {
-          continue;
-        }
-        const [rightKey, rightValue] = rightEntries[index];
-        if (stableValueEquals(leftKey, rightKey) && stableValueEquals(leftValue, rightValue)) {
-          matched.add(index);
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        return false;
-      }
-    }
-    return true;
   }
-  if (Array.isArray(left) || Array.isArray(right)) {
-    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+  return 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 left.every((value, index) => stableValueEquals(value, right[index]));
   }
+  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) {
@@ -5056,6 +5876,28 @@ function stableValueEquals(left, right) {
   }
   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");
 }
@@ -5415,94 +6257,6 @@ function validateSettings(raw) {
   return { success: true, data: result.value };
 }
 
-// dist/core/item/item-type-definition.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] = "257435ee-2ef3-5736-a403-57d6265cf280");
-  } catch (e2) {
-  }
-})();
-function normalizeItemTypeStringList(values) {
-  return [...new Set((values ?? []).map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeItemTypeOption(option) {
-  const key = option.key.trim();
-  if (key.length === 0) {
-    return null;
-  }
-  const aliases = normalizeItemTypeStringList(option.aliases);
-  const description = option.description?.trim();
-  return {
-    key,
-    values: normalizeItemTypeStringList(option.values),
-    required: option.required === true ? true : void 0,
-    aliases: aliases.length > 0 ? aliases : void 0,
-    description: description && description.length > 0 ? description : void 0
-  };
-}
-var keepPolicyCommand = (command) => command;
-var strictPolicyCommand = (command) => {
-  const normalized = command.trim().toLowerCase();
-  return normalized === "create" || normalized === "update" ? normalized : null;
-};
-function normalizeItemTypeCommandOptionPolicy(policy, resolvePolicyCommand) {
-  const command = resolvePolicyCommand(policy.command);
-  if (command === null) {
-    return null;
-  }
-  const option = policy.option.trim();
-  if (option.length === 0) {
-    return null;
-  }
-  return {
-    command,
-    option,
-    required: policy.required,
-    visible: policy.visible,
-    enabled: policy.enabled
-  };
-}
-function normalizeItemTypeCommandOptionPolicies(policies, resolvePolicyCommand) {
-  const dedupedByKey = /* @__PURE__ */ new Map();
-  for (const policy of policies ?? []) {
-    const normalized = normalizeItemTypeCommandOptionPolicy(policy, resolvePolicyCommand);
-    if (!normalized) {
-      continue;
-    }
-    dedupedByKey.set(`${normalized.command}:${normalized.option.toLowerCase()}`, normalized);
-  }
-  return [...dedupedByKey.values()].sort((left, right) => left.command === right.command ? left.option.localeCompare(right.option) : left.command.localeCompare(right.command));
-}
-function normalizeItemTypeDefinition(definition, options = {}) {
-  const resolvePolicyCommand = options.resolvePolicyCommand ?? keepPolicyCommand;
-  const name = definition.name.trim();
-  if (name.length === 0) {
-    return null;
-  }
-  const hasRequiredCreateFields = definition.required_create_fields !== void 0;
-  const hasRequiredCreateRepeatables = definition.required_create_repeatables !== void 0;
-  const hasOptions = definition.options !== void 0;
-  const hasCommandOptionPolicies = definition.command_option_policies !== void 0;
-  const folder = definition.folder?.trim();
-  const description = definition.description?.trim();
-  const defaultStatus = definition.default_status?.trim();
-  const aliases = normalizeItemTypeStringList(definition.aliases);
-  const normalizedOptions = (definition.options ?? []).map((option) => normalizeItemTypeOption(option)).filter((option) => option !== null).sort((left, right) => left.key.localeCompare(right.key));
-  const commandOptionPolicies = normalizeItemTypeCommandOptionPolicies(definition.command_option_policies, resolvePolicyCommand);
-  return {
-    name,
-    description: description && description.length > 0 ? description : void 0,
-    default_status: defaultStatus && defaultStatus.length > 0 ? defaultStatus : void 0,
-    folder: folder && folder.length > 0 ? folder : void 0,
-    aliases: aliases.length > 0 ? aliases : void 0,
-    required_create_fields: hasRequiredCreateFields ? normalizeItemTypeStringList(definition.required_create_fields) : void 0,
-    required_create_repeatables: hasRequiredCreateRepeatables ? normalizeItemTypeStringList(definition.required_create_repeatables) : void 0,
-    options: hasOptions ? normalizedOptions : void 0,
-    command_option_policies: hasCommandOptionPolicies ? commandOptionPolicies : void 0
-  };
-}
-
 // dist/core/validate/estimate-defaults.js
 !(function() {
   try {
@@ -5653,7 +6407,7 @@ function clearSettingsReadCache(pmRoot) {
 !(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] = "45ec3f18-8048-5e45-acc9-7544f0bffbde");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "76965ca9-e890-5aa2-a7ca-22f8d179dd5c");
   } catch (e2) {
   }
 })();
@@ -6126,19 +6880,19 @@ function mergeSettings(settings) {
     ...settings,
     item_format: settings.item_format === "json_markdown" ? "toon" : settings.item_format ?? defaults.item_format,
     locks: { ...defaults.locks, ...settings.locks },
-    checkpoints: { ...defaults.checkpoints, ...settings.checkpoints ?? {} },
+    checkpoints: { ...defaults.checkpoints, ...settings.checkpoints },
     output: { ...defaults.output, ...settings.output },
     history: {
       ...defaults.history,
-      ...settings.history ?? {},
+      ...settings.history,
       compact_policy: {
         ...defaults.history.compact_policy,
-        ...settings.history?.compact_policy ?? {}
+        ...settings.history?.compact_policy
       }
     },
     validation: {
       ...defaults.validation,
-      ...settings.validation ?? {},
+      ...settings.validation,
       parent_reference: governance.parent_reference,
       metadata_profile: governance.metadata_profile,
       metadata_required_fields: normalizeValidationMetadataRequiredFields(settings.validation?.metadata_required_fields),
@@ -6174,7 +6928,7 @@ function mergeSettings(settings) {
       stale_threshold_days: settings.context?.stale_threshold_days ?? defaults.context.stale_threshold_days,
       sections: {
         ...defaults.context.sections,
-        ...settings.context?.sections ?? {}
+        ...settings.context?.sections
       }
     },
     extensions: {
@@ -6188,13 +6942,13 @@ function mergeSettings(settings) {
       mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(settings.search?.mutation_refresh_policy),
       query_expansion: {
         ...defaults.search.query_expansion,
-        ...settings.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 ?? {},
+        ...settings.search?.rerank,
         enabled: normalizeSearchRerankEnabled(settings.search?.rerank?.enabled),
         model: normalizeSearchRerankModel(settings.search?.rerank?.model),
         top_k: normalizeSearchRerankTopK(settings.search?.rerank?.top_k)
@@ -6266,13 +7020,13 @@ function serializeSettings(settings, options = {}) {
       mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(baseSettings.search?.mutation_refresh_policy),
       query_expansion: {
         ...SETTINGS_DEFAULTS.search.query_expansion,
-        ...baseSettings.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 ?? {},
+        ...baseSettings.search?.rerank,
         enabled: normalizeSearchRerankEnabled(baseSettings.search?.rerank?.enabled),
         model: normalizeSearchRerankModel(baseSettings.search?.rerank?.model),
         top_k: normalizeSearchRerankTopK(baseSettings.search?.rerank?.top_k)
@@ -6284,7 +7038,7 @@ function serializeSettings(settings, options = {}) {
       stale_threshold_days: baseSettings.context?.stale_threshold_days ?? SETTINGS_DEFAULTS.context.stale_threshold_days,
       sections: {
         ...SETTINGS_DEFAULTS.context.sections,
-        ...baseSettings.context?.sections ?? {}
+        ...baseSettings.context?.sections
       }
     },
     extensions: {
@@ -6296,8 +7050,8 @@ function serializeSettings(settings, options = {}) {
       ...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 ?? {} }
+      qdrant: { ...baseSettings.vector_store?.qdrant },
+      lancedb: { ...baseSettings.vector_store?.lancedb }
     }
   };
   const ordered = orderObject({
@@ -6598,6 +7352,33 @@ export {
   EMPTY_CANONICAL_DOCUMENT,
   EXIT_CODE,
   resolveTelemetryErrorCategory,
+  BUILTIN_ITEM_TYPE_VALUES,
+  STATUS_VALUES,
+  RUNTIME_STATUS_ROLE_VALUES,
+  RUNTIME_FIELD_TYPE_VALUES,
+  RUNTIME_FIELD_COMMAND_VALUES,
+  DEPENDENCY_KIND_VALUES,
+  SCOPE_VALUES,
+  RISK_VALUES,
+  ISSUE_SEVERITY_VALUES,
+  CONFIDENCE_TEXT_VALUES,
+  RECURRENCE_FREQUENCY_VALUES,
+  RECURRENCE_WEEKDAY_VALUES,
+  weekdayOrderIndex,
+  PLAN_MODE_VALUES,
+  PLAN_STEP_STATUS_VALUES,
+  PLAN_HARNESS_VALUES,
+  PLAN_STEP_LINK_KIND_VALUES,
+  CONTEXT_DEPTH_VALUES,
+  CONTEXT_SECTION_VALUES,
+  canonicalizeCommandOptionKey,
+  commandOptionFlagLabel,
+  toDefaultFolder,
+  resolveItemTypeRegistry,
+  resolveTypeName,
+  resolveTypeDefinition,
+  resolveCommandOptionPolicyState,
+  validateTypeOptions,
   ITEM_FILE_EXTENSIONS,
   resolvePmRoot,
   resolveGlobalPmRoot,
@@ -6667,29 +7448,6 @@ export {
   runActiveRendererOverride,
   runActiveServiceOverride,
   runActiveServiceOverrideSync,
-  BUILTIN_ITEM_TYPE_VALUES,
-  ITEM_TYPE_VALUES,
-  STATUS_VALUES,
-  RUNTIME_STATUS_ROLE_VALUES,
-  RUNTIME_FIELD_TYPE_VALUES,
-  RUNTIME_FIELD_COMMAND_VALUES,
-  DEPENDENCY_KIND_VALUES,
-  SCOPE_VALUES,
-  RISK_VALUES,
-  ISSUE_SEVERITY_VALUES,
-  CONFIDENCE_TEXT_VALUES,
-  RECURRENCE_FREQUENCY_VALUES,
-  RECURRENCE_WEEKDAY_VALUES,
-  weekdayOrderIndex,
-  PLAN_MODE_VALUES,
-  PLAN_STEP_STATUS_VALUES,
-  PLAN_HARNESS_VALUES,
-  PLAN_STEP_LINK_KIND_VALUES,
-  CONTEXT_DEPTH_VALUES,
-  CONTEXT_SECTION_VALUES,
-  normalizeItemTypeStringList,
-  strictPolicyCommand,
-  normalizeItemTypeDefinition,
   DEFAULT_RUNTIME_SCHEMA_FILE_PATHS,
   DEFAULT_RUNTIME_STATUS_DEFINITIONS,
   normalizeRuntimeSchemaSettings,
@@ -6712,4 +7470,4 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-MJTSZKK5.js.map
+//# sourceMappingURL=chunk-SNUK7H5J.js.map