@unbrained/pm-cli 2026.6.24 → 2026.6.30

package/dist/cli-bundle/chunks/{chunk-VSAABFGQ.js → chunk-CY5IJMUM.js}

@@ -1,9 +1,10 @@
 // dist/core/fs/fs-utils.js
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1dd79a7a-ea00-583f-a03c-d08dc95ce458")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b452df4b-661b-5f08-9d20-dff37c4bfb2f")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
+var WINDOWS_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100];
 async function ensureDir(dirPath) {
   await fs.mkdir(dirPath, { recursive: true });
 }
@@ -33,6 +34,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);
@@ -171,6 +192,7 @@ var KNOWN_EXTENSION_POLICY_SURFACES = [
   "schema.itemfields",
   "schema.itemtypes",
   "schema.migrations",
+  "schema.profiles",
   "parser.override",
   "preflight.override",
   "services.override",
@@ -608,6 +630,794 @@ function resolveTelemetryErrorCategory(errorCode) {
   return "unknown";
 }
 
+// dist/types.js
+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/core/item/item-type-definition.js
+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
+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;
+    }
+    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);
+      }
+    }
+  }
+  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}"`);
+    }
+  }
+  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}"`]
+    };
+  }
+  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);
+    }
+  }
+  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;
+  }
+  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}"`);
+    }
+  }
+  const sortedKeys = Object.keys(normalized).sort((left, right) => left.localeCompare(right));
+  if (sortedKeys.length === 0) {
+    return {
+      normalized: void 0,
+      errors
+    };
+  }
+  return {
+    normalized: Object.fromEntries(sortedKeys.map((key) => [key, normalized[key]])),
+    errors
+  };
+}
+
 // dist/core/store/paths.js
 import { statSync } from "node:fs";
 import os from "node:os";
@@ -649,60 +1459,31 @@ function resolvePmRoot(cwd, cliPath) {
   const explicitPath = cliPath?.trim() || envPath?.trim();
   if (explicitPath) {
     const resolved = path4.resolve(cwd, explicitPath);
-    if (!pathExists2(getSettingsPath(resolved))) {
-      const nestedRoot = path4.join(resolved, PM_DIRNAME);
-      if (pathExists2(getSettingsPath(nestedRoot))) {
-        return nestedRoot;
-      }
-    }
-    return resolved;
-  }
-  const discoveredRoot = discoverPmRootFromAncestors(cwd);
-  if (discoveredRoot) {
-    return discoveredRoot;
-  }
-  const selected = PM_DIRNAME;
-  return path4.resolve(cwd, selected);
-}
-function resolveGlobalPmRoot(cwd) {
-  const envPath = process.env.PM_GLOBAL_PATH?.trim();
-  const selected = envPath && envPath.length > 0 ? envPath : path4.join(os.homedir(), ".pm-cli");
-  return path4.resolve(cwd, selected);
-}
-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 += "-";
+    if (!pathExists2(getSettingsPath(resolved))) {
+      const nestedRoot = path4.join(resolved, PM_DIRNAME);
+      if (pathExists2(getSettingsPath(nestedRoot))) {
+        return nestedRoot;
       }
-      slug += character;
-      pendingDash = false;
-      continue;
-    }
-    if (slug.length > 0) {
-      pendingDash = true;
     }
+    return resolved;
   }
-  return slug;
+  const discoveredRoot = discoverPmRootFromAncestors(cwd);
+  if (discoveredRoot) {
+    return discoveredRoot;
+  }
+  const selected = PM_DIRNAME;
+  return path4.resolve(cwd, selected);
+}
+function resolveGlobalPmRoot(cwd) {
+  const envPath = process.env.PM_GLOBAL_PATH?.trim();
+  const selected = envPath && envPath.length > 0 ? envPath : path4.join(os.homedir(), ".pm-cli");
+  return path4.resolve(cwd, selected);
+}
+function getSettingsPath(pmRoot) {
+  return path4.join(pmRoot, SETTINGS_FILENAME);
 }
 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) {
@@ -806,6 +1587,51 @@ function asRecordLoose(value) {
   return value;
 }
 
+// dist/core/shared/levenshtein.js
+function levenshteinDistanceWithinLimit(left, right, limit) {
+  if (left === right) {
+    return 0;
+  }
+  if (Math.abs(left.length - right.length) > limit) {
+    return null;
+  }
+  const width = right.length + 1;
+  const beforePrevious = new Array(width);
+  const previous = new Array(width);
+  const current = new Array(width);
+  for (let column = 0; column < width; column += 1) {
+    beforePrevious[column] = 0;
+    previous[column] = column;
+  }
+  for (let row = 1; row <= left.length; row += 1) {
+    current[0] = row;
+    let rowMin = current[0];
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      const substitution = previous[column - 1] + cost;
+      const insertion = current[column - 1] + 1;
+      const deletion = previous[column] + 1;
+      let candidate = Math.min(substitution, insertion, deletion);
+      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+        candidate = Math.min(candidate, beforePrevious[column - 2] + 1);
+      }
+      current[column] = candidate;
+      if (candidate < rowMin) {
+        rowMin = candidate;
+      }
+    }
+    if (rowMin > limit) {
+      return null;
+    }
+    for (let column = 0; column < width; column += 1) {
+      beforePrevious[column] = previous[column];
+      previous[column] = current[column];
+    }
+  }
+  const result = previous[right.length];
+  return result <= limit ? result : null;
+}
+
 // dist/core/extensions/extension-registries.js
 function createEmptyExtensionHookRegistry() {
   return {
@@ -849,6 +1675,7 @@ function createEmptyExtensionRegistrationRegistry() {
     item_fields: [],
     item_types: [],
     migrations: [],
+    profiles: [],
     importers: [],
     exporters: [],
     search_providers: [],
@@ -1329,51 +2156,6 @@ function isFlagDefaultValueCoercible(value, kind) {
   return typeof value === "string" && ["true", "false", "1", "0"].includes(value.trim().toLowerCase());
 }
 
-// dist/core/shared/levenshtein.js
-function levenshteinDistanceWithinLimit(left, right, limit) {
-  if (left === right) {
-    return 0;
-  }
-  if (Math.abs(left.length - right.length) > limit) {
-    return null;
-  }
-  const width = right.length + 1;
-  const beforePrevious = new Array(width);
-  const previous = new Array(width);
-  const current = new Array(width);
-  for (let column = 0; column < width; column += 1) {
-    beforePrevious[column] = 0;
-    previous[column] = column;
-  }
-  for (let row = 1; row <= left.length; row += 1) {
-    current[0] = row;
-    let rowMin = current[0];
-    for (let column = 1; column <= right.length; column += 1) {
-      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
-      const substitution = previous[column - 1] + cost;
-      const insertion = current[column - 1] + 1;
-      const deletion = previous[column] + 1;
-      let candidate = Math.min(substitution, insertion, deletion);
-      if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
-        candidate = Math.min(candidate, beforePrevious[column - 2] + 1);
-      }
-      current[column] = candidate;
-      if (candidate < rowMin) {
-        rowMin = candidate;
-      }
-    }
-    if (rowMin > limit) {
-      return null;
-    }
-    for (let column = 0; column < width; column += 1) {
-      beforePrevious[column] = previous[column];
-      previous[column] = current[column];
-    }
-  }
-  const result = previous[right.length];
-  return result <= limit ? result : null;
-}
-
 // dist/core/extensions/item-field-types.js
 var KNOWN_ITEM_FIELD_TYPES = ["string", "number", "boolean", "array", "object"];
 function normalizeItemFieldType(value) {
@@ -3078,6 +3860,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,
@@ -3379,6 +4241,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;
@@ -3577,6 +4452,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     registerItemFields,
     registerItemTypes,
     registerMigration,
+    registerProfile,
     registerRenderer,
     registerImporter,
     registerExporter,
@@ -3602,6 +4478,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,
@@ -3827,6 +4704,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");
@@ -4069,154 +4947,49 @@ function runActiveRendererOverride(format, result) {
       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/types.js
-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);
+    };
+  }
+  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));
 }
-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/core/schema/runtime-schema.js
 import path6 from "node:path";
@@ -4375,7 +5148,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 = (() => {
@@ -4640,7 +5413,7 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
     fields: [...normalizedSchema.fields, ...loadedFields ?? []],
     workflow: {
       ...normalizedSchema.workflow,
-      ...loadedWorkflow ?? {}
+      ...loadedWorkflow
     },
     type_workflows: [...normalizedSchema.type_workflows ?? [], ...loadedTypeWorkflows ?? []]
   });
@@ -4838,74 +5611,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;
+  }
+  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 RegExp || right instanceof RegExp) {
-    return left instanceof RegExp && right instanceof RegExp && left.toString() === right.toString();
+  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 Date || right instanceof Date) {
-    return left instanceof Date && right instanceof Date && left.getTime() === right.getTime();
+  if (!(left instanceof Set && right instanceof Set) || left.size !== right.size) {
+    return false;
   }
-  if (left instanceof Set || right instanceof Set) {
-    if (!(left instanceof Set && right instanceof Set) || 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 rightValues = [...right];
-    const matched = /* @__PURE__ */ new Set();
-    for (const leftValue of left) {
-      let found = false;
-      for (let index = 0; index < rightValues.length; index += 1) {
-        if (matched.has(index)) {
-          continue;
-        }
-        if (stableValueEquals(leftValue, rightValues[index])) {
-          matched.add(index);
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        return false;
-      }
-    }
-    return true;
   }
-  if (left instanceof Map || right instanceof Map) {
-    if (!(left instanceof Map && right instanceof Map) || left.size !== right.size) {
-      return false;
-    }
-    const rightEntries = [...right.entries()];
-    const matched = /* @__PURE__ */ new Set();
-    for (const [leftKey, leftValue] of left.entries()) {
-      let found = false;
-      for (let index = 0; index < rightEntries.length; index += 1) {
-        if (matched.has(index)) {
-          continue;
-        }
-        const [rightKey, rightValue] = rightEntries[index];
-        if (stableValueEquals(leftKey, rightKey) && stableValueEquals(leftValue, rightValue)) {
-          matched.add(index);
-          found = true;
-          break;
-        }
-      }
-      if (!found) {
-        return false;
-      }
-    }
-    return true;
+  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;
   }
-  if (Array.isArray(left) || Array.isArray(right)) {
-    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+  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) {
@@ -4922,6 +5694,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");
 }
@@ -5274,87 +6068,6 @@ function validateSettings(raw) {
   return { success: true, data: result.value };
 }
 
-// dist/core/item/item-type-definition.js
-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
 var DEFAULT_ESTIMATE_MINUTES_BY_TYPE = {
   Epic: 2880,
@@ -5957,19 +6670,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),
@@ -6005,7 +6718,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: {
@@ -6019,13 +6732,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)
@@ -6097,13 +6810,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)
@@ -6115,7 +6828,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: {
@@ -6127,8 +6840,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({
@@ -6429,6 +7142,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,
@@ -6498,29 +7238,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,
@@ -6543,6 +7260,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-VSAABFGQ.js.map
+//# sourceMappingURL=chunk-CY5IJMUM.js.map
 
-//# debugId=1dd79a7a-ea00-583f-a03c-d08dc95ce458
+//# debugId=b452df4b-661b-5f08-9d20-dff37c4bfb2f