@unbrained/pm-cli 2026.6.24 → 2026.7.1

package/dist/cli-bundle/chunks/{chunk-VSAABFGQ.js → chunk-7R4QEMZZ.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]="03ed13d8-75ea-5f3b-b089-a7347a59acca")}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";
@@ -655,54 +1465,25 @@ function resolvePmRoot(cwd, cliPath) {
         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 += "-";
-      }
-      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) {
@@ -1717,34 +2499,15 @@ function collectExtensionPolicyOverrides(rawOverrides) {
   }
   return overridesByName;
 }
-function normalizeExtensionPolicy(settings) {
-  const policy = settings.extensions.policy;
-  const mode = normalizePolicyMode(policy?.mode);
-  const trustMode = normalizePolicyTrustMode(policy?.trust_mode);
-  const pmMaxVersionExceededMode2 = normalizePmMaxVersionExceededMode(policy?.pm_max_version_exceeded_mode);
-  const requireProvenance = policy?.require_provenance === true;
-  const trustedExtensions = normalizePolicyStringSet(policy?.trusted_extensions);
-  const defaultSandboxProfile = normalizePolicySandboxProfile(policy?.default_sandbox_profile);
-  const allowedExtensions = normalizePolicyStringSet(policy?.allowed_extensions);
-  const blockedExtensions = normalizePolicyStringSet(policy?.blocked_extensions);
-  const allowedCapabilities = normalizePolicyStringSet(policy?.allowed_capabilities);
-  const blockedCapabilities = normalizePolicyStringSet(policy?.blocked_capabilities);
-  const allowedSurfaces = normalizePolicySurfaceSet(policy?.allowed_surfaces);
-  const blockedSurfaces = normalizePolicySurfaceSet(policy?.blocked_surfaces);
-  const allowedCommands = normalizePolicyStringSet(policy?.allowed_commands);
-  const blockedCommands = normalizePolicyStringSet(policy?.blocked_commands);
-  const allowedActions = normalizePolicyStringSet(policy?.allowed_actions);
-  const blockedActions = normalizePolicyStringSet(policy?.blocked_actions);
-  const allowedServices = normalizePolicyStringSet(policy?.allowed_services);
-  const blockedServices = normalizePolicyStringSet(policy?.blocked_services);
-  const overridesByName = collectExtensionPolicyOverrides(policy?.extension_overrides);
+function collectExtensionPolicyWarnings(normalized) {
   const warnings = [];
-  for (const capability of toSortedList([...allowedCapabilities, ...blockedCapabilities])) {
+  const sortedOverrides = [...normalized.overridesByName.values()].sort((left, right) => left.name.localeCompare(right.name));
+  for (const capability of toSortedList([...normalized.allowedCapabilities, ...normalized.blockedCapabilities])) {
     if (!isKnownExtensionCapability(capability)) {
       warnings.push(`extension_policy_unknown_capability:${capability}`);
     }
   }
-  for (const override of [...overridesByName.values()].sort((left, right) => left.name.localeCompare(right.name))) {
+  for (const override of sortedOverrides) {
     for (const capability of toSortedList([...override.allowedCapabilities, ...override.blockedCapabilities])) {
       if (!isKnownExtensionCapability(capability)) {
         warnings.push(`extension_policy_unknown_capability:${override.name}:${capability}`);
@@ -1752,39 +2515,54 @@ function normalizeExtensionPolicy(settings) {
     }
   }
   const knownSurfaces = new Set(KNOWN_EXTENSION_POLICY_SURFACES);
-  for (const surface of toSortedList([...allowedSurfaces, ...blockedSurfaces])) {
+  for (const surface of toSortedList([...normalized.allowedSurfaces, ...normalized.blockedSurfaces])) {
     if (!knownSurfaces.has(surface)) {
       warnings.push(`extension_policy_unknown_surface:${surface}`);
     }
   }
-  for (const override of [...overridesByName.values()].sort((left, right) => left.name.localeCompare(right.name))) {
+  for (const override of sortedOverrides) {
     for (const surface of toSortedList([...override.allowedSurfaces, ...override.blockedSurfaces])) {
       if (!knownSurfaces.has(surface)) {
         warnings.push(`extension_policy_unknown_surface:${override.name}:${surface}`);
       }
     }
   }
+  return [...new Set(warnings)].sort((left, right) => left.localeCompare(right));
+}
+function normalizeExtensionPolicy(settings) {
+  const policy = settings.extensions?.policy ?? {};
+  const allowedCapabilities = normalizePolicyStringSet(policy.allowed_capabilities);
+  const blockedCapabilities = normalizePolicyStringSet(policy.blocked_capabilities);
+  const allowedSurfaces = normalizePolicySurfaceSet(policy.allowed_surfaces);
+  const blockedSurfaces = normalizePolicySurfaceSet(policy.blocked_surfaces);
+  const overridesByName = collectExtensionPolicyOverrides(policy.extension_overrides);
   return {
-    mode,
-    trustMode,
-    pmMaxVersionExceededMode: pmMaxVersionExceededMode2,
-    requireProvenance,
-    trustedExtensions,
-    defaultSandboxProfile,
-    allowedExtensions,
-    blockedExtensions,
+    mode: normalizePolicyMode(policy.mode),
+    trustMode: normalizePolicyTrustMode(policy.trust_mode),
+    pmMaxVersionExceededMode: normalizePmMaxVersionExceededMode(policy.pm_max_version_exceeded_mode),
+    requireProvenance: policy.require_provenance === true,
+    trustedExtensions: normalizePolicyStringSet(policy.trusted_extensions),
+    defaultSandboxProfile: normalizePolicySandboxProfile(policy.default_sandbox_profile),
+    allowedExtensions: normalizePolicyStringSet(policy.allowed_extensions),
+    blockedExtensions: normalizePolicyStringSet(policy.blocked_extensions),
     allowedCapabilities,
     blockedCapabilities,
     allowedSurfaces,
     blockedSurfaces,
-    allowedCommands,
-    blockedCommands,
-    allowedActions,
-    blockedActions,
-    allowedServices,
-    blockedServices,
+    allowedCommands: normalizePolicyStringSet(policy.allowed_commands),
+    blockedCommands: normalizePolicyStringSet(policy.blocked_commands),
+    allowedActions: normalizePolicyStringSet(policy.allowed_actions),
+    blockedActions: normalizePolicyStringSet(policy.blocked_actions),
+    allowedServices: normalizePolicyStringSet(policy.allowed_services),
+    blockedServices: normalizePolicyStringSet(policy.blocked_services),
     overridesByName,
-    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right))
+    warnings: collectExtensionPolicyWarnings({
+      allowedCapabilities,
+      blockedCapabilities,
+      allowedSurfaces,
+      blockedSurfaces,
+      overridesByName
+    })
   };
 }
 function serializeExtensionPolicy(policy) {
@@ -1995,55 +2773,28 @@ function evaluateExtensionPolicyForExtension(policy, extension) {
   if (policy.mode === "off" && policy.trustMode === "off") {
     return { allowed: true, warning: null };
   }
+  const violations = [];
   const reason = resolvePolicyExtensionReason(policy, extension);
-  const trustReason = resolvePolicyTrustReason(policy, extension);
-  const sandboxReason = resolvePolicySandboxReason(policy, extension);
-  const extensionEnforced = reason && policy.mode === "enforce";
-  const trustEnforced = trustReason && policy.trustMode === "enforce";
-  const sandboxEnforced = sandboxReason && policy.mode === "enforce";
-  if (!reason && !trustReason && !sandboxReason) {
-    return { allowed: true, warning: null };
-  }
-  if (extensionEnforced) {
-    return {
-      allowed: false,
-      warning: buildPolicyWarning("blocked", "extension", extension, reason)
-    };
+  if (reason) {
+    violations.push({ reason, scope: "extension", mode: policy.mode });
   }
-  if (trustEnforced) {
-    return {
-      allowed: false,
-      warning: buildPolicyWarning("blocked", "trust", extension, trustReason)
-    };
-  }
-  if (sandboxEnforced) {
-    return {
-      allowed: false,
-      warning: buildPolicyWarning("blocked", "extension", extension, sandboxReason)
-    };
+  const trustReason = resolvePolicyTrustReason(policy, extension);
+  if (trustReason) {
+    violations.push({ reason: trustReason, scope: "trust", mode: policy.trustMode });
   }
-  if (reason && policy.mode === "warn") {
-    return {
-      allowed: true,
-      warning: buildPolicyWarning("violation", "extension", extension, reason)
-    };
+  const sandboxReason = resolvePolicySandboxReason(policy, extension);
+  if (sandboxReason) {
+    violations.push({ reason: sandboxReason, scope: "extension", mode: policy.mode });
   }
-  if (trustReason && policy.trustMode === "warn") {
-    return {
-      allowed: true,
-      warning: buildPolicyWarning("violation", "trust", extension, trustReason)
-    };
+  const enforced = violations.find((violation) => violation.mode === "enforce");
+  if (enforced) {
+    return { allowed: false, warning: buildPolicyWarning("blocked", enforced.scope, extension, enforced.reason) };
   }
-  if (sandboxReason && policy.mode === "warn") {
-    return {
-      allowed: true,
-      warning: buildPolicyWarning("violation", "extension", extension, sandboxReason)
-    };
+  const warned = violations.find((violation) => violation.mode === "warn");
+  if (warned) {
+    return { allowed: true, warning: buildPolicyWarning("violation", warned.scope, extension, warned.reason) };
   }
-  return {
-    allowed: true,
-    warning: null
-  };
+  return { allowed: true, warning: null };
 }
 function evaluateExtensionPolicyForCapability(policy, extension, capability) {
   if (policy.mode === "off") {
@@ -2058,19 +2809,15 @@ function evaluateExtensionPolicyForCapability(policy, extension, capability) {
     warning: buildPolicyWarning(policy.mode === "warn" ? "violation" : "blocked", "capability", extension, reason, { capability: capability.trim().toLowerCase() })
   };
 }
-function evaluateExtensionPolicyForRegistration(policy, extension, surface, method, capability, details) {
-  if (policy.mode === "off") {
-    return { allowed: true, warning: null };
-  }
+function resolveRegistrationPolicyReason(policy, extension, surface, capability, detail) {
   const capabilityReason = typeof capability === "string" ? resolvePolicyCapabilityReason(policy, extension, capability) : null;
   const surfaceReason = resolvePolicySurfaceReason(policy, extension, surface);
-  const commandReason = details?.command ? resolvePolicyCommandReason(policy, extension, details.command) : null;
-  const actionReason = details?.action ? resolvePolicyActionReason(policy, extension, details.action) : null;
-  const serviceReason = details?.service ? resolvePolicyServiceReason(policy, extension, details.service) : null;
-  const reason = capabilityReason ?? surfaceReason ?? commandReason ?? actionReason ?? serviceReason;
-  if (!reason) {
-    return { allowed: true, warning: null };
-  }
+  const commandReason = detail.command ? resolvePolicyCommandReason(policy, extension, detail.command) : null;
+  const actionReason = detail.action ? resolvePolicyActionReason(policy, extension, detail.action) : null;
+  const serviceReason = detail.service ? resolvePolicyServiceReason(policy, extension, detail.service) : null;
+  return capabilityReason ?? surfaceReason ?? commandReason ?? actionReason ?? serviceReason;
+}
+function buildRegistrationPolicyWarningDetails(method, surface, capability, detail) {
   const warningDetails = {
     method: normalizePolicyName(method).replace(/\s+/g, "_"),
     surface
@@ -2078,16 +2825,27 @@ function evaluateExtensionPolicyForRegistration(policy, extension, surface, meth
   if (capability) {
     warningDetails.capability = capability;
   }
-  if (details?.command) {
-    warningDetails.command = normalizeCommandName(details.command);
+  if (detail.command) {
+    warningDetails.command = normalizeCommandName(detail.command);
+  }
+  if (detail.action) {
+    warningDetails.action = normalizePolicyName(detail.action).replace(/\s+/g, "-");
   }
-  if (details?.action) {
-    warningDetails.action = normalizePolicyName(details.action).replace(/\s+/g, "-");
+  if (detail.service) {
+    warningDetails.service = normalizePolicyName(detail.service);
   }
-  if (details?.service) {
-    warningDetails.service = normalizePolicyName(details.service);
+  return warningDetails;
+}
+function evaluateExtensionPolicyForRegistration(policy, extension, surface, method, capability, details) {
+  if (policy.mode === "off") {
+    return { allowed: true, warning: null };
   }
-  const warning = buildPolicyWarning(policy.mode === "warn" ? "violation" : "blocked", "registration", extension, reason, warningDetails);
+  const detail = details ?? {};
+  const reason = resolveRegistrationPolicyReason(policy, extension, surface, capability, detail);
+  if (!reason) {
+    return { allowed: true, warning: null };
+  }
+  const warning = buildPolicyWarning(policy.mode === "warn" ? "violation" : "blocked", "registration", extension, reason, buildRegistrationPolicyWarningDetails(method, surface, capability, detail));
   return {
     allowed: policy.mode === "warn",
     warning
@@ -2134,33 +2892,134 @@ function parseManifestEngines(value) {
   }
   return Object.keys(engines).length > 0 ? engines : void 0;
 }
-function parseManifest(raw) {
-  if (typeof raw !== "object" || raw === null) {
+function parseRequiredManifestString(candidate, field) {
+  const value = candidate[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
     return null;
   }
-  const candidate = raw;
-  if (typeof candidate.name !== "string" || candidate.name.trim().length === 0) {
+  return value.trim();
+}
+function parseOptionalIntegerValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value)) {
     return null;
   }
-  if (typeof candidate.version !== "string" || candidate.version.trim().length === 0) {
+  return value;
+}
+function parseOptionalBooleanValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
     return null;
   }
-  if (typeof candidate.entry !== "string" || candidate.entry.trim().length === 0) {
+  return value;
+}
+function parseManifestPriority(candidate) {
+  const value = parseOptionalIntegerValue(candidate.priority);
+  return value === void 0 ? DEFAULT_EXTENSION_PRIORITY : value;
+}
+function parseManifestSandboxProfile(candidate) {
+  const value = candidate.sandbox_profile;
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
     return null;
   }
-  let priority = DEFAULT_EXTENSION_PRIORITY;
-  if ("priority" in candidate && candidate.priority !== void 0 && candidate.priority !== null) {
-    if (typeof candidate.priority !== "number" || !Number.isInteger(candidate.priority)) {
-      return null;
-    }
-    priority = candidate.priority;
+  const normalizedProfile = normalizePolicySandboxProfile(value);
+  if (normalizedProfile !== value.trim().toLowerCase()) {
+    return null;
   }
-  let manifestVersion;
-  if ("manifest_version" in candidate && candidate.manifest_version !== void 0 && candidate.manifest_version !== null) {
-    if (typeof candidate.manifest_version !== "number" || !Number.isInteger(candidate.manifest_version)) {
-      return null;
-    }
-    manifestVersion = candidate.manifest_version;
+  return normalizedProfile;
+}
+function optionalTrimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function parseManifestProvenance(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const provenanceRecord = asRecordLoose(value);
+  if (!provenanceRecord) {
+    return null;
+  }
+  const source = optionalTrimmedString(provenanceRecord.source);
+  const signature = optionalTrimmedString(provenanceRecord.signature);
+  const attestation = optionalTrimmedString(provenanceRecord.attestation);
+  const verified = provenanceRecord.verified === void 0 || provenanceRecord.verified === null ? void 0 : typeof provenanceRecord.verified === "boolean" ? provenanceRecord.verified : null;
+  if (verified === null) {
+    return null;
+  }
+  return {
+    ...source ? { source } : {},
+    ...signature ? { signature } : {},
+    ...attestation ? { attestation } : {},
+    ...typeof verified === "boolean" ? { verified } : {}
+  };
+}
+function parseManifestPermissions(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const permissionsRecord = asRecordLoose(value);
+  if (!permissionsRecord) {
+    return null;
+  }
+  const fsRead = parseOptionalBooleanValue(permissionsRecord.fs_read);
+  const fsWrite = parseOptionalBooleanValue(permissionsRecord.fs_write);
+  const network = parseOptionalBooleanValue(permissionsRecord.network);
+  const envRead = parseOptionalBooleanValue(permissionsRecord.env_read);
+  const envWrite = parseOptionalBooleanValue(permissionsRecord.env_write);
+  const processSpawn = parseOptionalBooleanValue(permissionsRecord.process_spawn);
+  if ([fsRead, fsWrite, network, envRead, envWrite, processSpawn].includes(null)) {
+    return null;
+  }
+  return {
+    ...typeof fsRead === "boolean" ? { fs_read: fsRead } : {},
+    ...typeof fsWrite === "boolean" ? { fs_write: fsWrite } : {},
+    ...typeof network === "boolean" ? { network } : {},
+    ...typeof envRead === "boolean" ? { env_read: envRead } : {},
+    ...typeof envWrite === "boolean" ? { env_write: envWrite } : {},
+    ...typeof processSpawn === "boolean" ? { process_spawn: processSpawn } : {}
+  };
+}
+function parseManifestCapabilities(value) {
+  if (value === void 0 || value === null) {
+    return { capabilities: [], legacy_aliases: [] };
+  }
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    return null;
+  }
+  const normalizedCapabilities = normalizeManifestCapabilities(value);
+  return { capabilities: normalizedCapabilities.capabilities, legacy_aliases: normalizedCapabilities.legacy_aliases };
+}
+function parseManifestActivation(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const activationRecord = asRecordLoose(value);
+  if (!activationRecord) {
+    return null;
+  }
+  const rawCommands = activationRecord.commands;
+  if (rawCommands === void 0 || rawCommands === null) {
+    return void 0;
+  }
+  if (!Array.isArray(rawCommands) || rawCommands.some((entry) => typeof entry !== "string")) {
+    return null;
+  }
+  const commands = [
+    ...new Set(rawCommands.map((entry) => normalizeCommandName(entry)).filter((entry) => entry.length > 0))
+  ].sort((left, right) => left.localeCompare(right));
+  return commands.length > 0 ? { commands } : void 0;
+}
+function parseManifestMetadata(candidate) {
+  const manifestVersion = parseOptionalIntegerValue(candidate.manifest_version);
+  if (manifestVersion === null) {
+    return null;
   }
   const pmMinVersion = parseOptionalManifestString(candidate, "pm_min_version");
   if (pmMinVersion === null) {
@@ -2174,124 +3033,85 @@ function parseManifest(raw) {
   if (engines === null) {
     return null;
   }
-  let trusted;
-  if ("trusted" in candidate && candidate.trusted !== void 0 && candidate.trusted !== null) {
-    if (typeof candidate.trusted !== "boolean") {
-      return null;
-    }
-    trusted = candidate.trusted;
+  const trusted = parseOptionalBooleanValue(candidate.trusted);
+  if (trusted === null) {
+    return null;
   }
-  let sandboxProfile;
-  if ("sandbox_profile" in candidate && candidate.sandbox_profile !== void 0 && candidate.sandbox_profile !== null) {
-    if (typeof candidate.sandbox_profile !== "string") {
-      return null;
-    }
-    const normalizedProfile = normalizePolicySandboxProfile(candidate.sandbox_profile);
-    if (normalizedProfile !== candidate.sandbox_profile.trim().toLowerCase()) {
-      return null;
-    }
-    sandboxProfile = normalizedProfile;
+  const sandboxProfile = parseManifestSandboxProfile(candidate);
+  if (sandboxProfile === null) {
+    return null;
   }
-  let provenance;
-  if ("provenance" in candidate && candidate.provenance !== void 0 && candidate.provenance !== null) {
-    const provenanceRecord = asRecordLoose(candidate.provenance);
-    if (!provenanceRecord) {
-      return null;
-    }
-    const source = typeof provenanceRecord.source === "string" && provenanceRecord.source.trim().length > 0 ? provenanceRecord.source.trim() : void 0;
-    const signature = typeof provenanceRecord.signature === "string" && provenanceRecord.signature.trim().length > 0 ? provenanceRecord.signature.trim() : void 0;
-    const attestation = typeof provenanceRecord.attestation === "string" && provenanceRecord.attestation.trim().length > 0 ? provenanceRecord.attestation.trim() : void 0;
-    const verified = provenanceRecord.verified === void 0 || provenanceRecord.verified === null ? void 0 : typeof provenanceRecord.verified === "boolean" ? provenanceRecord.verified : null;
-    if (verified === null) {
-      return null;
-    }
-    provenance = {
-      ...source ? { source } : {},
-      ...signature ? { signature } : {},
-      ...attestation ? { attestation } : {},
-      ...typeof verified === "boolean" ? { verified } : {}
-    };
+  const provenance = parseManifestProvenance(candidate.provenance);
+  if (provenance === null) {
+    return null;
   }
-  let permissions;
-  if ("permissions" in candidate && candidate.permissions !== void 0 && candidate.permissions !== null) {
-    const permissionsRecord = asRecordLoose(candidate.permissions);
-    if (!permissionsRecord) {
-      return null;
-    }
-    const parseOptionalBoolean = (value) => {
-      if (value === void 0 || value === null) {
-        return void 0;
-      }
-      if (typeof value !== "boolean") {
-        return null;
-      }
-      return value;
-    };
-    const fsRead = parseOptionalBoolean(permissionsRecord.fs_read);
-    const fsWrite = parseOptionalBoolean(permissionsRecord.fs_write);
-    const network = parseOptionalBoolean(permissionsRecord.network);
-    const envRead = parseOptionalBoolean(permissionsRecord.env_read);
-    const envWrite = parseOptionalBoolean(permissionsRecord.env_write);
-    const processSpawn = parseOptionalBoolean(permissionsRecord.process_spawn);
-    if ([fsRead, fsWrite, network, envRead, envWrite, processSpawn].includes(null)) {
-      return null;
-    }
-    permissions = {
-      ...typeof fsRead === "boolean" ? { fs_read: fsRead } : {},
-      ...typeof fsWrite === "boolean" ? { fs_write: fsWrite } : {},
-      ...typeof network === "boolean" ? { network } : {},
-      ...typeof envRead === "boolean" ? { env_read: envRead } : {},
-      ...typeof envWrite === "boolean" ? { env_write: envWrite } : {},
-      ...typeof processSpawn === "boolean" ? { process_spawn: processSpawn } : {}
-    };
+  const permissions = parseManifestPermissions(candidate.permissions);
+  if (permissions === null) {
+    return null;
   }
-  let capabilities = [];
-  let legacyCapabilityAliases = [];
-  if ("capabilities" in candidate && candidate.capabilities !== void 0 && candidate.capabilities !== null) {
-    if (!Array.isArray(candidate.capabilities) || candidate.capabilities.some((value) => typeof value !== "string")) {
-      return null;
-    }
-    const normalizedCapabilities = normalizeManifestCapabilities(candidate.capabilities);
-    capabilities = normalizedCapabilities.capabilities;
-    legacyCapabilityAliases = normalizedCapabilities.legacy_aliases;
+  const capabilities = parseManifestCapabilities(candidate.capabilities);
+  if (capabilities === null) {
+    return null;
   }
-  let activation;
-  if ("activation" in candidate && candidate.activation !== void 0 && candidate.activation !== null) {
-    const activationRecord = asRecordLoose(candidate.activation);
-    if (!activationRecord) {
-      return null;
-    }
-    const rawCommands = activationRecord.commands;
-    if (rawCommands !== void 0 && rawCommands !== null) {
-      if (!Array.isArray(rawCommands) || rawCommands.some((value) => typeof value !== "string")) {
-        return null;
-      }
-      const commands = [
-        ...new Set(rawCommands.map((value) => normalizeCommandName(value)).filter((value) => value.length > 0))
-      ].sort((left, right) => left.localeCompare(right));
-      if (commands.length > 0) {
-        activation = {
-          commands
-        };
-      }
-    }
+  const activation = parseManifestActivation(candidate.activation);
+  if (activation === null) {
+    return null;
   }
   return {
-    name: candidate.name.trim(),
-    version: candidate.version.trim(),
-    entry: candidate.entry.trim(),
-    priority,
     manifest_version: manifestVersion,
     pm_min_version: pmMinVersion,
     pm_max_version: pmMaxVersion,
     engines,
     trusted,
-    provenance,
     sandbox_profile: sandboxProfile,
+    provenance,
     permissions,
-    activation,
-    capabilities,
-    legacy_capability_aliases: legacyCapabilityAliases.length > 0 ? legacyCapabilityAliases : void 0
+    capabilities: capabilities.capabilities,
+    legacy_capability_aliases: capabilities.legacy_aliases,
+    activation
+  };
+}
+function parseManifest(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return null;
+  }
+  const candidate = raw;
+  const name = parseRequiredManifestString(candidate, "name");
+  if (name === null) {
+    return null;
+  }
+  const version = parseRequiredManifestString(candidate, "version");
+  if (version === null) {
+    return null;
+  }
+  const entry = parseRequiredManifestString(candidate, "entry");
+  if (entry === null) {
+    return null;
+  }
+  const priority = parseManifestPriority(candidate);
+  if (priority === null) {
+    return null;
+  }
+  const metadata = parseManifestMetadata(candidate);
+  if (metadata === null) {
+    return null;
+  }
+  return {
+    name,
+    version,
+    entry,
+    priority,
+    manifest_version: metadata.manifest_version,
+    pm_min_version: metadata.pm_min_version,
+    pm_max_version: metadata.pm_max_version,
+    engines: metadata.engines,
+    trusted: metadata.trusted,
+    provenance: metadata.provenance,
+    sandbox_profile: metadata.sandbox_profile,
+    permissions: metadata.permissions,
+    activation: metadata.activation,
+    capabilities: metadata.capabilities,
+    legacy_capability_aliases: metadata.legacy_capability_aliases.length > 0 ? metadata.legacy_capability_aliases : void 0
   };
 }
 function shouldEnable(name, enabled, disabled) {
@@ -2420,26 +3240,50 @@ async function scanExtensionLayer(layer, extensionsRoot, enabled, disabled, pmMa
   }
   return { diagnostics, warnings, candidates };
 }
+function buildUnavailableExtensionScan(layer, directory, manifestPath, warning) {
+  return {
+    diagnostic: {
+      layer,
+      directory,
+      manifest_path: manifestPath,
+      name: null,
+      version: null,
+      entry: null,
+      priority: null,
+      entry_path: null,
+      enabled: null,
+      status: "warn"
+    },
+    warnings: [warning],
+    candidate: null
+  };
+}
+function collectScannedExtensionWarnings(layer, manifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility) {
+  const extensionWarnings = [];
+  if (Array.isArray(manifest.legacy_capability_aliases) && manifest.legacy_capability_aliases.length > 0) {
+    extensionWarnings.push(formatLegacyExtensionCapabilityAliasWarning(layer, manifest.name, manifest.legacy_capability_aliases));
+  }
+  for (const capability of collectUnknownExtensionCapabilities(manifest.capabilities)) {
+    extensionWarnings.push(formatUnknownExtensionCapabilityWarning(layer, manifest.name, capability));
+  }
+  if (!entryWithinDirectory) {
+    extensionWarnings.push(`extension_entry_outside_extension:${layer}:${manifest.name}`);
+  } else if (!entryExists) {
+    extensionWarnings.push(`extension_entry_missing:${layer}:${manifest.name}`);
+  }
+  if (pmVersionCompatibility.warning) {
+    extensionWarnings.push(pmVersionCompatibility.warning);
+  }
+  if (pmMaxVersionCompatibility.warning) {
+    extensionWarnings.push(pmMaxVersionCompatibility.warning);
+  }
+  return extensionWarnings;
+}
 async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled, disabled, managedSourcePackages, pmMaxVersionExceededMode2) {
   const extensionDir = path5.join(extensionsRoot, directory);
   const manifestPath = path5.join(extensionDir, "manifest.json");
   if (!await pathExists(manifestPath)) {
-    return {
-      diagnostic: {
-        layer,
-        directory,
-        manifest_path: manifestPath,
-        name: null,
-        version: null,
-        entry: null,
-        priority: null,
-        entry_path: null,
-        enabled: null,
-        status: "warn"
-      },
-      warnings: [`extension_manifest_missing:${layer}:${directory}`],
-      candidate: null
-    };
+    return buildUnavailableExtensionScan(layer, directory, manifestPath, `extension_manifest_missing:${layer}:${directory}`);
   }
   let manifest = null;
   try {
@@ -2449,48 +3293,16 @@ async function scanExtensionDirectory(layer, extensionsRoot, directory, enabled,
     manifest = null;
   }
   if (!manifest) {
-    return {
-      diagnostic: {
-        layer,
-        directory,
-        manifest_path: manifestPath,
-        name: null,
-        version: null,
-        entry: null,
-        priority: null,
-        entry_path: null,
-        enabled: null,
-        status: "warn"
-      },
-      warnings: [`extension_manifest_invalid:${layer}:${directory}`],
-      candidate: null
-    };
+    return buildUnavailableExtensionScan(layer, directory, manifestPath, `extension_manifest_invalid:${layer}:${directory}`);
   }
   const entryPath = path5.resolve(extensionDir, manifest.entry);
   const entryWithinDirectoryByPath = isPathWithinDirectory(extensionDir, entryPath);
   const entryExists = entryWithinDirectoryByPath ? await pathExists(entryPath) : false;
   const entryWithinDirectory = entryWithinDirectoryByPath && entryExists ? await isCanonicalPathWithinDirectory(extensionDir, entryPath) : entryWithinDirectoryByPath;
   const enabledForLoad = shouldEnable(manifest.name, enabled, disabled);
-  const extensionWarnings = [];
-  if (Array.isArray(manifest.legacy_capability_aliases) && manifest.legacy_capability_aliases.length > 0) {
-    extensionWarnings.push(formatLegacyExtensionCapabilityAliasWarning(layer, manifest.name, manifest.legacy_capability_aliases));
-  }
-  for (const capability of collectUnknownExtensionCapabilities(manifest.capabilities)) {
-    extensionWarnings.push(formatUnknownExtensionCapabilityWarning(layer, manifest.name, capability));
-  }
-  if (!entryWithinDirectory) {
-    extensionWarnings.push(`extension_entry_outside_extension:${layer}:${manifest.name}`);
-  } else if (!entryExists) {
-    extensionWarnings.push(`extension_entry_missing:${layer}:${manifest.name}`);
-  }
   const pmVersionCompatibility = await evaluatePmMinVersionCompatibility(layer, manifest);
-  if (pmVersionCompatibility.warning) {
-    extensionWarnings.push(pmVersionCompatibility.warning);
-  }
   const pmMaxVersionCompatibility = await evaluatePmMaxVersionCompatibility(layer, manifest, pmMaxVersionExceededMode2);
-  if (pmMaxVersionCompatibility.warning) {
-    extensionWarnings.push(pmMaxVersionCompatibility.warning);
-  }
+  const extensionWarnings = collectScannedExtensionWarnings(layer, manifest, entryWithinDirectory, entryExists, pmVersionCompatibility, pmMaxVersionCompatibility);
   const extensionReady = entryWithinDirectory && entryExists && pmVersionCompatibility.allowed && pmMaxVersionCompatibility.allowed;
   const sourcePackage = managedSourcePackages.get(`directory:${directory}`) ?? managedSourcePackages.get(`name:${manifest.name}`);
   return {
@@ -3078,6 +3890,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,
@@ -3160,69 +4052,70 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     received: sanitizeRegistrationValue(received),
     hint
   });
-  const registerCommand = (commandOrDefinition, override) => {
-    assertExtensionCapability(extension, "commands", "registerCommand");
-    if (typeof commandOrDefinition === "string") {
-      const normalizedCommand2 = normalizeCommandName(commandOrDefinition);
-      if (normalizedCommand2.length === 0) {
-        throw createRegistrationValidationError("registerCommand requires a non-empty command name", registerCommandTrace("override", commandOrDefinition, 'registerCommand("<command>", (context) => unknown)', commandOrDefinition, "Provide a non-empty command path as the first argument."));
-      }
-      if (typeof override !== "function") {
-        const trace = registerCommandTrace("override", normalizedCommand2, 'registerCommand("<command>", (context) => unknown)', { command: commandOrDefinition, override }, "Provide a function as the second registerCommand argument.");
-        throw createRegistrationValidationError(`registerCommand requires an override function when command name is provided (command="${normalizedCommand2}", registration_index=${trace.registration_index})`, trace);
-      }
-      if (!allowRegistration("commands.override", "registerCommand", "commands", { command: normalizedCommand2 })) {
-        return;
-      }
-      commands.overrides.push({
-        layer: extension.layer,
-        name: extension.name,
-        command: normalizedCommand2,
-        run: override
-      });
-      return;
-    }
-    if (typeof commandOrDefinition !== "object" || commandOrDefinition === null) {
-      throw createRegistrationValidationError("registerCommand requires a command definition object", registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", commandOrDefinition, 'Use registerCommand({ name: "command path", run: (context) => ... }).'));
+  const registerCommandOverride = (command, override) => {
+    const normalizedCommand = normalizeCommandName(command);
+    if (normalizedCommand.length === 0) {
+      throw createRegistrationValidationError("registerCommand requires a non-empty command name", registerCommandTrace("override", command, 'registerCommand("<command>", (context) => unknown)', command, "Provide a non-empty command path as the first argument."));
     }
-    if (typeof commandOrDefinition.name !== "string") {
-      throw createRegistrationValidationError("registerCommand requires a command definition name", registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", commandOrDefinition, "Set command definition.name to a non-empty string command path."));
+    if (typeof override !== "function") {
+      const trace = registerCommandTrace("override", normalizedCommand, 'registerCommand("<command>", (context) => unknown)', { command, override }, "Provide a function as the second registerCommand argument.");
+      throw createRegistrationValidationError(`registerCommand requires an override function when command name is provided (command="${normalizedCommand}", registration_index=${trace.registration_index})`, trace);
     }
-    const normalizedCommand = normalizeCommandName(commandOrDefinition.name);
-    if (normalizedCommand.length === 0) {
-      throw createRegistrationValidationError("registerCommand requires a non-empty command definition name", registerCommandTrace("definition", commandOrDefinition.name, "{ name: string; run: (context) => unknown; }", commandOrDefinition, "Ensure command definition.name contains a non-empty command path."));
+    if (!allowRegistration("commands.override", "registerCommand", "commands", { command: normalizedCommand })) {
+      return;
     }
-    const runHandler = typeof commandOrDefinition.run === "function" ? commandOrDefinition.run : void 0;
-    const legacyHandler = typeof commandOrDefinition.handler === "function" ? commandOrDefinition.handler : void 0;
+    commands.overrides.push({
+      layer: extension.layer,
+      name: extension.name,
+      command: normalizedCommand,
+      run: override
+    });
+  };
+  const resolveCommandDefinitionRunHandler = (definition, normalizedCommand) => {
+    const runHandler = typeof definition.run === "function" ? definition.run : void 0;
+    const legacyHandler = typeof definition.handler === "function" ? definition.handler : void 0;
     if (!runHandler && legacyHandler) {
       activationWarnings.push(`extension_command_definition_legacy_handler_alias:${extension.layer}:${extension.name}:${normalizedCommand}`);
     }
-    const resolvedHandler = runHandler ?? legacyHandler;
+    return runHandler ?? legacyHandler;
+  };
+  const registerCommandDefinition = (definition) => {
+    if (typeof definition !== "object" || definition === null) {
+      throw createRegistrationValidationError("registerCommand requires a command definition object", registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", definition, 'Use registerCommand({ name: "command path", run: (context) => ... }).'));
+    }
+    if (typeof definition.name !== "string") {
+      throw createRegistrationValidationError("registerCommand requires a command definition name", registerCommandTrace("definition", void 0, "{ name: string; run: (context) => unknown; }", definition, "Set command definition.name to a non-empty string command path."));
+    }
+    const normalizedCommand = normalizeCommandName(definition.name);
+    if (normalizedCommand.length === 0) {
+      throw createRegistrationValidationError("registerCommand requires a non-empty command definition name", registerCommandTrace("definition", definition.name, "{ name: string; run: (context) => unknown; }", definition, "Ensure command definition.name contains a non-empty command path."));
+    }
+    const resolvedHandler = resolveCommandDefinitionRunHandler(definition, normalizedCommand);
     if (typeof resolvedHandler !== "function") {
-      const trace = registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; }", commandOrDefinition, "Define command definition.run as a function.");
+      const trace = registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; }", definition, "Define command definition.run as a function.");
       throw createRegistrationValidationError(`registerCommand requires a command definition run handler (command="${normalizedCommand}", registration_index=${trace.registration_index})`, trace);
     }
     try {
-      assertOptionalStringField("registerCommand definition.action", commandOrDefinition.action);
-      assertOptionalStringField("registerCommand definition.description", commandOrDefinition.description);
-      assertOptionalStringField("registerCommand definition.intent", commandOrDefinition.intent);
-      const action = resolveCommandDefinitionAction(normalizedCommand, commandOrDefinition.action);
+      assertOptionalStringField("registerCommand definition.action", definition.action);
+      assertOptionalStringField("registerCommand definition.description", definition.description);
+      assertOptionalStringField("registerCommand definition.intent", definition.intent);
+      const action = resolveCommandDefinitionAction(normalizedCommand, definition.action);
       if (!allowRegistration("commands.handler", "registerCommand", "commands", { command: normalizedCommand, action })) {
         return;
       }
-      const description = commandOrDefinition.description?.trim();
-      const intent = commandOrDefinition.intent?.trim();
-      const examples = normalizeOptionalStringArrayField("registerCommand definition.examples", commandOrDefinition.examples);
-      const failureHints = normalizeOptionalStringArrayField("registerCommand definition.failure_hints", commandOrDefinition.failure_hints);
-      const argumentsDefinition = normalizeCommandDefinitionArguments(commandOrDefinition.arguments);
-      if (commandOrDefinition.flags !== void 0) {
+      const description = definition.description?.trim();
+      const intent = definition.intent?.trim();
+      const examples = normalizeOptionalStringArrayField("registerCommand definition.examples", definition.examples);
+      const failureHints = normalizeOptionalStringArrayField("registerCommand definition.failure_hints", definition.failure_hints);
+      const argumentsDefinition = normalizeCommandDefinitionArguments(definition.arguments);
+      if (definition.flags !== void 0) {
         assertExtensionCapability(extension, "schema", "registerCommand flags");
-        validateFlagDefinitions(commandOrDefinition.flags);
+        validateFlagDefinitions(definition.flags);
         registrations.flags.push({
           layer: extension.layer,
           name: extension.name,
           target_command: normalizedCommand,
-          flags: normalizeRegistrationRecordList("registerCommand definition.flags", commandOrDefinition.flags)
+          flags: normalizeRegistrationRecordList("registerCommand definition.flags", definition.flags)
         });
       }
       const registration = {
@@ -3244,7 +4137,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       registrations.commands.push(registration);
     } catch (error) {
       const reason = formatUnknownError(error);
-      const trace = registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; action?: string; arguments?: object[]; flags?: object[]; }", commandOrDefinition, "Use schema-style metadata (action/arguments/flags/examples/intent) with valid values.");
+      const trace = registerCommandTrace("definition", normalizedCommand, "{ name: string; run: (context) => unknown; action?: string; arguments?: object[]; flags?: object[]; }", definition, "Use schema-style metadata (action/arguments/flags/examples/intent) with valid values.");
       throw createRegistrationValidationError(`registerCommand definition metadata invalid (command="${normalizedCommand}", registration_index=${trace.registration_index}): ${reason}`, trace);
     }
     commands.handlers.push({
@@ -3254,6 +4147,14 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
       run: resolvedHandler
     });
   };
+  const registerCommand = (commandOrDefinition, override) => {
+    assertExtensionCapability(extension, "commands", "registerCommand");
+    if (typeof commandOrDefinition === "string") {
+      registerCommandOverride(commandOrDefinition, override);
+      return;
+    }
+    registerCommandDefinition(commandOrDefinition);
+  };
   const registerParser = (command, override) => {
     assertExtensionCapability(extension, "parser", "registerParser");
     if (!allowRegistration("parser.override", "registerParser", "parser")) {
@@ -3379,6 +4280,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 +4491,7 @@ function createExtensionApi(extension, hooks, commands, parsers, preflight, serv
     registerItemFields,
     registerItemTypes,
     registerMigration,
+    registerProfile,
     registerRenderer,
     registerImporter,
     registerExporter,
@@ -3602,6 +4517,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 +4743,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 +4986,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 +5187,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 +5452,7 @@ async function loadRuntimeSchemaFromOptionalFiles(pmRoot, schema) {
     fields: [...normalizedSchema.fields, ...loadedFields ?? []],
     workflow: {
       ...normalizedSchema.workflow,
-      ...loadedWorkflow ?? {}
+      ...loadedWorkflow
     },
     type_workflows: [...normalizedSchema.type_workflows ?? [], ...loadedTypeWorkflows ?? []]
   });
@@ -4838,74 +5650,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 +5733,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 +6107,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 +6709,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 +6757,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 +6771,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 +6849,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 +6867,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 +6879,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 +7181,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 +7277,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 +7299,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-VSAABFGQ.js.map
+//# sourceMappingURL=chunk-7R4QEMZZ.js.map
 
-//# debugId=1dd79a7a-ea00-583f-a03c-d08dc95ce458
+//# debugId=03ed13d8-75ea-5f3b-b089-a7347a59acca