@unbrained/pm-cli 2026.6.30 → 2026.7.2

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

@@ -1,6 +1,6 @@
 // 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]="b452df4b-661b-5f08-9d20-dff37c4bfb2f")}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]="a360c40f-2d95-561b-8d26-69af3a10c107")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -787,6 +787,13 @@ function normalizeItemTypeCommandOptionPolicies(policies, resolvePolicyCommand)
   }
   return [...dedupedByKey.values()].sort((left, right) => left.command === right.command ? left.option.localeCompare(right.option) : left.command.localeCompare(right.command));
 }
+function normalizeOptionalStringList(values, preservePresence) {
+  return preservePresence ? normalizeItemTypeStringList(values) : void 0;
+}
+function optionalNonEmptyString(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
 function normalizeItemTypeDefinition(definition, options = {}) {
   const resolvePolicyCommand = options.resolvePolicyCommand ?? keepPolicyCommand;
   const name = definition.name.trim();
@@ -797,20 +804,17 @@ function normalizeItemTypeDefinition(definition, options = {}) {
   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,
+    description: optionalNonEmptyString(definition.description),
+    default_status: optionalNonEmptyString(definition.default_status),
+    folder: optionalNonEmptyString(definition.folder),
     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,
+    required_create_fields: normalizeOptionalStringList(definition.required_create_fields, hasRequiredCreateFields),
+    required_create_repeatables: normalizeOptionalStringList(definition.required_create_repeatables, hasRequiredCreateRepeatables),
     options: hasOptions ? normalizedOptions : void 0,
     command_option_policies: hasCommandOptionPolicies ? commandOptionPolicies : void 0
   };
@@ -1125,6 +1129,58 @@ function toSlugToken(value) {
 function normalizeTypeDefinition(definition) {
   return normalizeItemTypeDefinition(definition, { resolvePolicyCommand: strictPolicyCommand });
 }
+function readStringArray(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : void 0;
+}
+function coerceOptionDefinitionFromUnknown(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return null;
+  }
+  const optionRecord = raw;
+  if (typeof optionRecord.key !== "string") {
+    return null;
+  }
+  return {
+    key: optionRecord.key,
+    values: readStringArray(optionRecord, "values") ?? [],
+    required: optionRecord.required === void 0 ? void 0 : Boolean(optionRecord.required),
+    aliases: readStringArray(optionRecord, "aliases"),
+    description: typeof optionRecord.description === "string" ? optionRecord.description : void 0
+  };
+}
+function coerceCommandOptionPolicyFromUnknown(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return null;
+  }
+  const policyRecord = raw;
+  if (typeof policyRecord.command !== "string" || typeof policyRecord.option !== "string") {
+    return null;
+  }
+  const normalizedCommand = policyRecord.command.trim().toLowerCase();
+  if (normalizedCommand !== "create" && normalizedCommand !== "update") {
+    return null;
+  }
+  return {
+    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)
+  };
+}
+function coerceOptionDefinitionsFromRecord(record) {
+  if (!Array.isArray(record.options)) {
+    return void 0;
+  }
+  return record.options.map((entry) => coerceOptionDefinitionFromUnknown(entry)).filter((entry) => entry !== null);
+}
+function coerceCommandOptionPoliciesFromRecord(record) {
+  if (!Array.isArray(record.command_option_policies)) {
+    return void 0;
+  }
+  return record.command_option_policies.map((entry) => coerceCommandOptionPolicyFromUnknown(entry)).filter((entry) => entry !== null);
+}
 function coerceTypeDefinitionFromUnknown(raw) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     return null;
@@ -1137,65 +1193,30 @@ function coerceTypeDefinitionFromUnknown(raw) {
   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
+    aliases: readStringArray(record, "aliases"),
+    required_create_fields: readStringArray(record, "required_create_fields"),
+    required_create_repeatables: readStringArray(record, "required_create_repeatables"),
+    options: coerceOptionDefinitionsFromRecord(record),
+    command_option_policies: coerceCommandOptionPoliciesFromRecord(record)
   };
 }
+function resolveDefinitionRequiredCreateFields(normalizedDefinition, existing) {
+  return normalizedDefinition.required_create_fields ? normalizeItemTypeStringList(normalizedDefinition.required_create_fields) : existing?.required_create_fields ?? [];
+}
+function resolveDefinitionRequiredCreateRepeatables(normalizedDefinition, existing) {
+  return normalizedDefinition.required_create_repeatables ? normalizeItemTypeStringList(normalizedDefinition.required_create_repeatables) : existing?.required_create_repeatables ?? [];
+}
+function resolveDefinitionOptions(normalizedDefinition, existing) {
+  return normalizedDefinition.options ? normalizedDefinition.options : existing?.options ? [...existing.options] : [];
+}
+function resolveDefinitionCommandOptionPolicies(normalizedDefinition, existing) {
+  return normalizedDefinition.command_option_policies ? normalizedDefinition.command_option_policies : existing?.command_option_policies ? [...existing.command_option_policies] : [];
+}
 function applyTypeDefinitions(source, target) {
   for (const rawDefinition of source) {
     const normalizedDefinition = normalizeTypeDefinition(rawDefinition);
@@ -1210,10 +1231,6 @@ function applyTypeDefinitions(source, target) {
       ...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, {
@@ -1222,10 +1239,10 @@ function applyTypeDefinitions(source, target) {
       ...defaultStatus ? { default_status: defaultStatus } : {},
       folder,
       aliases,
-      required_create_fields: requiredCreateFields,
-      required_create_repeatables: requiredCreateRepeatables,
-      options,
-      command_option_policies: commandOptionPolicies
+      required_create_fields: resolveDefinitionRequiredCreateFields(normalizedDefinition, existing),
+      required_create_repeatables: resolveDefinitionRequiredCreateRepeatables(normalizedDefinition, existing),
+      options: resolveDefinitionOptions(normalizedDefinition, existing),
+      command_option_policies: resolveDefinitionCommandOptionPolicies(normalizedDefinition, existing)
     });
   }
 }
@@ -2499,34 +2516,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}`);
@@ -2534,39 +2532,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) {
@@ -2777,55 +2790,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 (reason) {
+    violations.push({ reason, scope: "extension", mode: policy.mode });
   }
-  if (extensionEnforced) {
-    return {
-      allowed: false,
-      warning: buildPolicyWarning("blocked", "extension", extension, reason)
-    };
-  }
-  if (trustEnforced) {
-    return {
-      allowed: false,
-      warning: buildPolicyWarning("blocked", "trust", extension, trustReason)
-    };
+  const trustReason = resolvePolicyTrustReason(policy, extension);
+  if (trustReason) {
+    violations.push({ reason: trustReason, scope: "trust", mode: policy.trustMode });
   }
-  if (sandboxEnforced) {
-    return {
-      allowed: false,
-      warning: buildPolicyWarning("blocked", "extension", extension, sandboxReason)
-    };
+  const sandboxReason = resolvePolicySandboxReason(policy, extension);
+  if (sandboxReason) {
+    violations.push({ reason: sandboxReason, scope: "extension", mode: policy.mode });
   }
-  if (reason && policy.mode === "warn") {
-    return {
-      allowed: true,
-      warning: buildPolicyWarning("violation", "extension", extension, reason)
-    };
+  const enforced = violations.find((violation) => violation.mode === "enforce");
+  if (enforced) {
+    return { allowed: false, warning: buildPolicyWarning("blocked", enforced.scope, extension, enforced.reason) };
   }
-  if (trustReason && policy.trustMode === "warn") {
-    return {
-      allowed: true,
-      warning: buildPolicyWarning("violation", "trust", extension, trustReason)
-    };
+  const warned = violations.find((violation) => violation.mode === "warn");
+  if (warned) {
+    return { allowed: true, warning: buildPolicyWarning("violation", warned.scope, extension, warned.reason) };
   }
-  if (sandboxReason && policy.mode === "warn") {
-    return {
-      allowed: true,
-      warning: buildPolicyWarning("violation", "extension", extension, sandboxReason)
-    };
-  }
-  return {
-    allowed: true,
-    warning: null
-  };
+  return { allowed: true, warning: null };
 }
 function evaluateExtensionPolicyForCapability(policy, extension, capability) {
   if (policy.mode === "off") {
@@ -2840,19 +2826,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
@@ -2860,16 +2842,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 (detail.service) {
+    warningDetails.service = normalizePolicyName(detail.service);
   }
-  if (details?.action) {
-    warningDetails.action = normalizePolicyName(details.action).replace(/\s+/g, "-");
+  return warningDetails;
+}
+function evaluateExtensionPolicyForRegistration(policy, extension, surface, method, capability, details) {
+  if (policy.mode === "off") {
+    return { allowed: true, warning: null };
   }
-  if (details?.service) {
-    warningDetails.service = normalizePolicyName(details.service);
+  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, warningDetails);
+  const warning = buildPolicyWarning(policy.mode === "warn" ? "violation" : "blocked", "registration", extension, reason, buildRegistrationPolicyWarningDetails(method, surface, capability, detail));
   return {
     allowed: policy.mode === "warn",
     warning
@@ -2916,33 +2909,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) {
@@ -2956,124 +3050,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) {
@@ -3202,26 +3257,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 {
@@ -3231,48 +3310,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 {
@@ -4022,69 +4069,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 = {
@@ -4106,7 +4154,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({
@@ -4116,6 +4164,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")) {
@@ -5064,40 +5120,47 @@ function normalizeRuntimeWorkflow(workflow) {
     canceled_status: normalizeStatusId(workflow?.canceled_status)
   };
 }
+function appendTypeWorkflowPair(record, pair) {
+  if (!Array.isArray(pair) || pair.length !== 2) {
+    return;
+  }
+  const from = normalizeStatusToken(pair[0]);
+  const to = normalizeStatusToken(pair[1]);
+  if (from.length === 0 || to.length === 0) {
+    return;
+  }
+  if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
+    return;
+  }
+  record.pairs.push([from, to]);
+}
+function normalizedTypeWorkflowEntry(entry) {
+  const rawType = typeof entry?.type === "string" ? entry.type.trim() : "";
+  if (rawType.length === 0 || !Array.isArray(entry?.allowed_transitions)) {
+    return null;
+  }
+  const record = { type: rawType, pairs: [], denyAll: entry.allowed_transitions.length === 0 };
+  for (const pair of entry.allowed_transitions) {
+    appendTypeWorkflowPair(record, pair);
+  }
+  return { typeKey: rawType.toLowerCase(), record };
+}
 function normalizeTypeWorkflowDefinitions(workflows) {
   if (!Array.isArray(workflows) || workflows.length === 0) {
     return void 0;
   }
   const byTypeKey = /* @__PURE__ */ new Map();
   for (const entry of workflows) {
-    const rawType = typeof entry?.type === "string" ? entry.type.trim() : "";
-    if (rawType.length === 0) {
-      continue;
-    }
-    if (!Array.isArray(entry?.allowed_transitions)) {
+    const normalized2 = normalizedTypeWorkflowEntry(entry);
+    if (normalized2 === null) {
       continue;
     }
-    const typeKey = rawType.toLowerCase();
-    const pairs = entry.allowed_transitions;
-    const record = byTypeKey.get(typeKey) ?? { type: rawType, pairs: [], denyAll: false };
-    if (pairs.length === 0) {
-      record.denyAll = true;
-    }
-    for (const pair of pairs) {
-      if (!Array.isArray(pair) || pair.length !== 2) {
-        continue;
-      }
-      const from = normalizeStatusToken(pair[0]);
-      const to = normalizeStatusToken(pair[1]);
-      if (from.length === 0 || to.length === 0) {
-        continue;
-      }
-      if (record.pairs.some((candidate) => candidate[0] === from && candidate[1] === to)) {
-        continue;
-      }
-      record.pairs.push([from, to]);
+    const record = byTypeKey.get(normalized2.typeKey) ?? normalized2.record;
+    record.denyAll ||= normalized2.record.denyAll;
+    for (const pair of normalized2.record.pairs) {
+      appendTypeWorkflowPair(record, pair);
     }
-    byTypeKey.set(typeKey, record);
+    byTypeKey.set(normalized2.typeKey, record);
   }
   const normalized = [];
   for (const record of byTypeKey.values()) {
@@ -6601,29 +6664,31 @@ function normalizePmMaxVersionExceededModeSetting(value) {
   }
   return void 0;
 }
+function normalizeExtensionPolicyList(policy, key) {
+  return normalizeLowerStringList(policy?.[key] ?? SETTINGS_DEFAULTS.extensions.policy[key]);
+}
 function normalizeExtensionPolicySettings(policy) {
-  const defaults = SETTINGS_DEFAULTS.extensions.policy;
   const pmMaxVersionExceededMode2 = normalizePmMaxVersionExceededModeSetting(policy?.pm_max_version_exceeded_mode);
   return {
     mode: normalizeExtensionPolicyMode(policy?.mode),
     trust_mode: normalizeExtensionTrustMode(policy?.trust_mode),
     ...pmMaxVersionExceededMode2 !== void 0 ? { pm_max_version_exceeded_mode: pmMaxVersionExceededMode2 } : {},
     require_provenance: policy?.require_provenance === true,
-    trusted_extensions: normalizeLowerStringList(policy?.trusted_extensions ?? defaults.trusted_extensions),
+    trusted_extensions: normalizeExtensionPolicyList(policy, "trusted_extensions"),
     default_sandbox_profile: normalizeExtensionSandboxProfile(policy?.default_sandbox_profile),
-    allowed_extensions: normalizeLowerStringList(policy?.allowed_extensions ?? defaults.allowed_extensions),
-    blocked_extensions: normalizeLowerStringList(policy?.blocked_extensions ?? defaults.blocked_extensions),
-    allowed_capabilities: normalizeLowerStringList(policy?.allowed_capabilities ?? defaults.allowed_capabilities),
-    blocked_capabilities: normalizeLowerStringList(policy?.blocked_capabilities ?? defaults.blocked_capabilities),
-    allowed_surfaces: normalizeLowerStringList(policy?.allowed_surfaces ?? defaults.allowed_surfaces),
-    blocked_surfaces: normalizeLowerStringList(policy?.blocked_surfaces ?? defaults.blocked_surfaces),
-    allowed_commands: normalizeLowerStringList(policy?.allowed_commands ?? defaults.allowed_commands),
-    blocked_commands: normalizeLowerStringList(policy?.blocked_commands ?? defaults.blocked_commands),
-    allowed_actions: normalizeLowerStringList(policy?.allowed_actions ?? defaults.allowed_actions),
-    blocked_actions: normalizeLowerStringList(policy?.blocked_actions ?? defaults.blocked_actions),
-    allowed_services: normalizeLowerStringList(policy?.allowed_services ?? defaults.allowed_services),
-    blocked_services: normalizeLowerStringList(policy?.blocked_services ?? defaults.blocked_services),
-    extension_overrides: normalizeExtensionPolicyOverrides(policy?.extension_overrides ?? defaults.extension_overrides)
+    allowed_extensions: normalizeExtensionPolicyList(policy, "allowed_extensions"),
+    blocked_extensions: normalizeExtensionPolicyList(policy, "blocked_extensions"),
+    allowed_capabilities: normalizeExtensionPolicyList(policy, "allowed_capabilities"),
+    blocked_capabilities: normalizeExtensionPolicyList(policy, "blocked_capabilities"),
+    allowed_surfaces: normalizeExtensionPolicyList(policy, "allowed_surfaces"),
+    blocked_surfaces: normalizeExtensionPolicyList(policy, "blocked_surfaces"),
+    allowed_commands: normalizeExtensionPolicyList(policy, "allowed_commands"),
+    blocked_commands: normalizeExtensionPolicyList(policy, "blocked_commands"),
+    allowed_actions: normalizeExtensionPolicyList(policy, "allowed_actions"),
+    blocked_actions: normalizeExtensionPolicyList(policy, "blocked_actions"),
+    allowed_services: normalizeExtensionPolicyList(policy, "allowed_services"),
+    blocked_services: normalizeExtensionPolicyList(policy, "blocked_services"),
+    extension_overrides: normalizeExtensionPolicyOverrides(policy?.extension_overrides ?? SETTINGS_DEFAULTS.extensions.policy.extension_overrides)
   };
 }
 function normalizeValidationMetadataRequiredFields(values) {
@@ -6652,6 +6717,81 @@ function recordOrEmpty(value) {
 function arrayOrEmpty(value) {
   return Array.isArray(value) ? value : [];
 }
+function buildValidationSettings(settings, defaults, governance) {
+  return {
+    ...defaults.validation,
+    ...settings.validation,
+    parent_reference: governance.parent_reference,
+    metadata_profile: governance.metadata_profile,
+    metadata_required_fields: normalizeValidationMetadataRequiredFields(settings.validation?.metadata_required_fields),
+    lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_stale_blocker_reason_patterns ?? defaults.validation.lifecycle_stale_blocker_reason_patterns),
+    lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? defaults.validation.lifecycle_closure_like_blocked_reason_patterns),
+    lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_resolution_patterns ?? defaults.validation.lifecycle_closure_like_resolution_patterns),
+    lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_actual_result_patterns ?? defaults.validation.lifecycle_closure_like_actual_result_patterns),
+    estimate_defaults_by_type: normalizeEstimateDefaultOverrides(settings.validation?.estimate_defaults_by_type)
+  };
+}
+function buildTelemetrySettings(settings, defaults) {
+  return {
+    enabled: settings.telemetry?.enabled ?? defaults.telemetry.enabled,
+    first_run_prompt_completed: settings.telemetry?.first_run_prompt_completed ?? defaults.telemetry.first_run_prompt_completed,
+    capture_level: settings.telemetry?.capture_level ?? defaults.telemetry.capture_level,
+    endpoint: settings.telemetry?.endpoint ?? defaults.telemetry.endpoint,
+    installation_id: settings.telemetry?.installation_id ?? defaults.telemetry.installation_id,
+    retention_days: settings.telemetry?.retention_days ?? defaults.telemetry.retention_days
+  };
+}
+function buildSearchSettings(settings, defaults) {
+  return {
+    ...defaults.search,
+    ...settings.search,
+    mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(settings.search?.mutation_refresh_policy),
+    query_expansion: {
+      ...defaults.search.query_expansion,
+      ...settings.search?.query_expansion,
+      enabled: normalizeSearchQueryExpansionEnabled(settings.search?.query_expansion?.enabled),
+      provider: normalizeSearchQueryExpansionProvider(settings.search?.query_expansion?.provider)
+    },
+    rerank: {
+      ...defaults.search.rerank,
+      ...settings.search?.rerank,
+      enabled: normalizeSearchRerankEnabled(settings.search?.rerank?.enabled),
+      model: normalizeSearchRerankModel(settings.search?.rerank?.model),
+      top_k: normalizeSearchRerankTopK(settings.search?.rerank?.top_k)
+    }
+  };
+}
+function buildVectorStoreSettings(settings, defaults) {
+  return {
+    adapter: settings.vector_store.adapter ?? defaults.vector_store.adapter,
+    collection_name: normalizeVectorStoreCollectionName(settings.vector_store.collection_name),
+    qdrant: { ...defaults.vector_store.qdrant, ...settings.vector_store.qdrant },
+    lancedb: { ...defaults.vector_store.lancedb, ...settings.vector_store.lancedb }
+  };
+}
+function normalizeSettingsItemFormat(settings, defaults) {
+  if (settings.item_format === "json_markdown") {
+    return "toon";
+  }
+  return settings.item_format ?? defaults.item_format;
+}
+function buildContextSettings(settings, defaults) {
+  return {
+    default_depth: settings.context?.default_depth ?? defaults.context.default_depth,
+    activity_limit: settings.context?.activity_limit ?? defaults.context.activity_limit,
+    stale_threshold_days: settings.context?.stale_threshold_days ?? defaults.context.stale_threshold_days,
+    sections: {
+      ...defaults.context.sections,
+      ...settings.context?.sections
+    }
+  };
+}
+function buildProviderSettings(settings, defaults) {
+  return {
+    openai: { ...defaults.providers.openai, ...settings.providers.openai },
+    ollama: { ...defaults.providers.ollama, ...settings.providers.ollama }
+  };
+}
 function normalizeItemTypeDefinitions(definitions) {
   const normalized = (definitions ?? []).map((definition) => normalizeItemTypeDefinition(definition)).filter((definition) => definition !== null);
   const dedupedByName = /* @__PURE__ */ new Map();
@@ -6668,7 +6808,7 @@ function mergeSettings(settings) {
   return {
     ...defaults,
     ...settings,
-    item_format: settings.item_format === "json_markdown" ? "toon" : settings.item_format ?? defaults.item_format,
+    item_format: normalizeSettingsItemFormat(settings, defaults),
     locks: { ...defaults.locks, ...settings.locks },
     checkpoints: { ...defaults.checkpoints, ...settings.checkpoints },
     output: { ...defaults.output, ...settings.output },
@@ -6680,18 +6820,7 @@ function mergeSettings(settings) {
         ...settings.history?.compact_policy
       }
     },
-    validation: {
-      ...defaults.validation,
-      ...settings.validation,
-      parent_reference: governance.parent_reference,
-      metadata_profile: governance.metadata_profile,
-      metadata_required_fields: normalizeValidationMetadataRequiredFields(settings.validation?.metadata_required_fields),
-      lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_stale_blocker_reason_patterns ?? defaults.validation.lifecycle_stale_blocker_reason_patterns),
-      lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? defaults.validation.lifecycle_closure_like_blocked_reason_patterns),
-      lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_resolution_patterns ?? defaults.validation.lifecycle_closure_like_resolution_patterns),
-      lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(settings.validation?.lifecycle_closure_like_actual_result_patterns ?? defaults.validation.lifecycle_closure_like_actual_result_patterns),
-      estimate_defaults_by_type: normalizeEstimateDefaultOverrides(settings.validation?.estimate_defaults_by_type)
-    },
+    validation: buildValidationSettings(settings, defaults, governance),
     governance,
     workflow: {
       definition_of_done: [...settings.workflow?.definition_of_done ?? defaults.workflow.definition_of_done]
@@ -6699,177 +6828,24 @@ function mergeSettings(settings) {
     testing: {
       record_results_to_items: settings.testing?.record_results_to_items ?? defaults.testing.record_results_to_items
     },
-    telemetry: {
-      enabled: settings.telemetry?.enabled ?? defaults.telemetry.enabled,
-      first_run_prompt_completed: settings.telemetry?.first_run_prompt_completed ?? defaults.telemetry.first_run_prompt_completed,
-      capture_level: settings.telemetry?.capture_level ?? defaults.telemetry.capture_level,
-      endpoint: settings.telemetry?.endpoint ?? defaults.telemetry.endpoint,
-      installation_id: settings.telemetry?.installation_id ?? defaults.telemetry.installation_id,
-      retention_days: settings.telemetry?.retention_days ?? defaults.telemetry.retention_days
-    },
+    telemetry: buildTelemetrySettings(settings, defaults),
     agent_guidance: normalizeAgentGuidanceSettings(settings.agent_guidance ?? defaults.agent_guidance),
     item_types: {
       definitions: normalizeItemTypeDefinitions(settings.item_types?.definitions)
     },
     schema: normalizeRuntimeSchemaSettings(settings.schema ?? defaults.schema),
-    context: {
-      default_depth: settings.context?.default_depth ?? defaults.context.default_depth,
-      activity_limit: settings.context?.activity_limit ?? defaults.context.activity_limit,
-      stale_threshold_days: settings.context?.stale_threshold_days ?? defaults.context.stale_threshold_days,
-      sections: {
-        ...defaults.context.sections,
-        ...settings.context?.sections
-      }
-    },
+    context: buildContextSettings(settings, defaults),
     extensions: {
       enabled: [...settings.extensions.enabled],
       disabled: [...settings.extensions.disabled],
       policy: normalizeExtensionPolicySettings(settings.extensions.policy ?? defaults.extensions.policy)
     },
-    search: {
-      ...defaults.search,
-      ...settings.search,
-      mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(settings.search?.mutation_refresh_policy),
-      query_expansion: {
-        ...defaults.search.query_expansion,
-        ...settings.search?.query_expansion,
-        enabled: normalizeSearchQueryExpansionEnabled(settings.search?.query_expansion?.enabled),
-        provider: normalizeSearchQueryExpansionProvider(settings.search?.query_expansion?.provider)
-      },
-      rerank: {
-        ...defaults.search.rerank,
-        ...settings.search?.rerank,
-        enabled: normalizeSearchRerankEnabled(settings.search?.rerank?.enabled),
-        model: normalizeSearchRerankModel(settings.search?.rerank?.model),
-        top_k: normalizeSearchRerankTopK(settings.search?.rerank?.top_k)
-      }
-    },
-    providers: {
-      openai: { ...defaults.providers.openai, ...settings.providers.openai },
-      ollama: { ...defaults.providers.ollama, ...settings.providers.ollama }
-    },
-    vector_store: {
-      adapter: settings.vector_store.adapter ?? defaults.vector_store.adapter,
-      collection_name: normalizeVectorStoreCollectionName(settings.vector_store.collection_name),
-      qdrant: { ...defaults.vector_store.qdrant, ...settings.vector_store.qdrant },
-      lancedb: { ...defaults.vector_store.lancedb, ...settings.vector_store.lancedb }
-    }
+    search: buildSearchSettings(settings, defaults),
+    providers: buildProviderSettings(settings, defaults),
+    vector_store: buildVectorStoreSettings(settings, defaults)
   };
 }
-function serializeSettings(settings, options = {}) {
-  const baseSettings = {
-    ...settings,
-    locks: valueOrDefault(settings.locks, SETTINGS_DEFAULTS.locks),
-    checkpoints: valueOrDefault(settings.checkpoints, SETTINGS_DEFAULTS.checkpoints),
-    output: valueOrDefault(settings.output, SETTINGS_DEFAULTS.output),
-    history: valueOrDefault(settings.history, SETTINGS_DEFAULTS.history),
-    validation: valueOrDefault(settings.validation, SETTINGS_DEFAULTS.validation),
-    workflow: valueOrDefault(settings.workflow, SETTINGS_DEFAULTS.workflow),
-    testing: valueOrDefault(settings.testing, SETTINGS_DEFAULTS.testing),
-    telemetry: valueOrDefault(settings.telemetry, SETTINGS_DEFAULTS.telemetry),
-    agent_guidance: valueOrDefault(settings.agent_guidance, SETTINGS_DEFAULTS.agent_guidance),
-    item_types: valueOrDefault(settings.item_types, SETTINGS_DEFAULTS.item_types),
-    schema: valueOrDefault(settings.schema, SETTINGS_DEFAULTS.schema),
-    context: valueOrDefault(settings.context, SETTINGS_DEFAULTS.context),
-    extensions: valueOrDefault(settings.extensions, SETTINGS_DEFAULTS.extensions),
-    search: valueOrDefault(settings.search, SETTINGS_DEFAULTS.search),
-    providers: valueOrDefault(settings.providers, SETTINGS_DEFAULTS.providers),
-    vector_store: valueOrDefault(settings.vector_store, SETTINGS_DEFAULTS.vector_store)
-  };
-  const governance = resolveGovernanceKnobs(baseSettings);
-  const normalizedSchema = normalizeRuntimeSchemaSettings(baseSettings.schema);
-  const persistedFileBackedSections = resolvePersistedFileBackedSchemaSections(baseSettings, options.persist_source);
-  const normalizedSettings = {
-    ...baseSettings,
-    item_format: "toon",
-    validation: {
-      ...baseSettings.validation,
-      parent_reference: governance.parent_reference,
-      metadata_profile: governance.metadata_profile,
-      metadata_required_fields: normalizeValidationMetadataRequiredFields(baseSettings.validation?.metadata_required_fields),
-      lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_stale_blocker_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_stale_blocker_reason_patterns),
-      lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_blocked_reason_patterns),
-      lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_resolution_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_resolution_patterns),
-      lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_actual_result_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_actual_result_patterns),
-      estimate_defaults_by_type: normalizeEstimateDefaultOverrides(baseSettings.validation?.estimate_defaults_by_type)
-    },
-    governance,
-    agent_guidance: normalizeAgentGuidanceSettings(baseSettings.agent_guidance),
-    item_types: {
-      definitions: persistedFileBackedSections.item_type_definitions
-    },
-    schema: {
-      ...normalizedSchema,
-      statuses: persistedFileBackedSections.schema_statuses,
-      fields: persistedFileBackedSections.schema_fields,
-      type_workflows: persistedFileBackedSections.schema_type_workflows
-    },
-    search: {
-      ...SETTINGS_DEFAULTS.search,
-      ...baseSettings.search,
-      mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(baseSettings.search?.mutation_refresh_policy),
-      query_expansion: {
-        ...SETTINGS_DEFAULTS.search.query_expansion,
-        ...baseSettings.search?.query_expansion,
-        enabled: normalizeSearchQueryExpansionEnabled(baseSettings.search?.query_expansion?.enabled),
-        provider: normalizeSearchQueryExpansionProvider(baseSettings.search?.query_expansion?.provider)
-      },
-      rerank: {
-        ...SETTINGS_DEFAULTS.search.rerank,
-        ...baseSettings.search?.rerank,
-        enabled: normalizeSearchRerankEnabled(baseSettings.search?.rerank?.enabled),
-        model: normalizeSearchRerankModel(baseSettings.search?.rerank?.model),
-        top_k: normalizeSearchRerankTopK(baseSettings.search?.rerank?.top_k)
-      }
-    },
-    context: {
-      default_depth: baseSettings.context?.default_depth ?? SETTINGS_DEFAULTS.context.default_depth,
-      activity_limit: baseSettings.context?.activity_limit ?? SETTINGS_DEFAULTS.context.activity_limit,
-      stale_threshold_days: baseSettings.context?.stale_threshold_days ?? SETTINGS_DEFAULTS.context.stale_threshold_days,
-      sections: {
-        ...SETTINGS_DEFAULTS.context.sections,
-        ...baseSettings.context?.sections
-      }
-    },
-    extensions: {
-      enabled: normalizeStringList2(baseSettings.extensions?.enabled),
-      disabled: normalizeStringList2(baseSettings.extensions?.disabled),
-      policy: normalizeExtensionPolicySettings(baseSettings.extensions?.policy)
-    },
-    vector_store: {
-      ...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 }
-    }
-  };
-  const ordered = orderObject({
-    ...normalizedSettings,
-    governance: normalizeGovernanceForPersist(governance)
-  }, [
-    "version",
-    "id_prefix",
-    "author_default",
-    "item_format",
-    "locks",
-    "checkpoints",
-    "output",
-    "history",
-    "validation",
-    "governance",
-    "workflow",
-    "testing",
-    "telemetry",
-    "agent_guidance",
-    "item_types",
-    "schema",
-    "context",
-    "extensions",
-    "search",
-    "providers",
-    "vector_store"
-  ]);
+function orderSerializedSettingsSections(ordered) {
   ordered.locks = orderObject(ordered.locks, ["ttl_seconds"]);
   ordered.checkpoints = orderObject(ordered.checkpoints, ["retention_days"]);
   ordered.output = orderObject(ordered.output, ["default_format"]);
@@ -6999,6 +6975,140 @@ function serializeSettings(settings, options = {}) {
   ]);
   ordered.vector_store.qdrant = orderObject(recordOrEmpty(ordered.vector_store.qdrant), ["url", "api_key"]);
   ordered.vector_store.lancedb = orderObject(recordOrEmpty(ordered.vector_store.lancedb), ["path"]);
+}
+function buildSerializeBaseSettings(settings) {
+  return {
+    ...settings,
+    locks: valueOrDefault(settings.locks, SETTINGS_DEFAULTS.locks),
+    checkpoints: valueOrDefault(settings.checkpoints, SETTINGS_DEFAULTS.checkpoints),
+    output: valueOrDefault(settings.output, SETTINGS_DEFAULTS.output),
+    history: valueOrDefault(settings.history, SETTINGS_DEFAULTS.history),
+    validation: valueOrDefault(settings.validation, SETTINGS_DEFAULTS.validation),
+    workflow: valueOrDefault(settings.workflow, SETTINGS_DEFAULTS.workflow),
+    testing: valueOrDefault(settings.testing, SETTINGS_DEFAULTS.testing),
+    telemetry: valueOrDefault(settings.telemetry, SETTINGS_DEFAULTS.telemetry),
+    agent_guidance: valueOrDefault(settings.agent_guidance, SETTINGS_DEFAULTS.agent_guidance),
+    item_types: valueOrDefault(settings.item_types, SETTINGS_DEFAULTS.item_types),
+    schema: valueOrDefault(settings.schema, SETTINGS_DEFAULTS.schema),
+    context: valueOrDefault(settings.context, SETTINGS_DEFAULTS.context),
+    extensions: valueOrDefault(settings.extensions, SETTINGS_DEFAULTS.extensions),
+    search: valueOrDefault(settings.search, SETTINGS_DEFAULTS.search),
+    providers: valueOrDefault(settings.providers, SETTINGS_DEFAULTS.providers),
+    vector_store: valueOrDefault(settings.vector_store, SETTINGS_DEFAULTS.vector_store)
+  };
+}
+function buildSerializedValidationSettings(baseSettings, governance) {
+  return {
+    ...baseSettings.validation,
+    parent_reference: governance.parent_reference,
+    metadata_profile: governance.metadata_profile,
+    metadata_required_fields: normalizeValidationMetadataRequiredFields(baseSettings.validation?.metadata_required_fields),
+    lifecycle_stale_blocker_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_stale_blocker_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_stale_blocker_reason_patterns),
+    lifecycle_closure_like_blocked_reason_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_blocked_reason_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_blocked_reason_patterns),
+    lifecycle_closure_like_resolution_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_resolution_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_resolution_patterns),
+    lifecycle_closure_like_actual_result_patterns: normalizeValidationPatternList(baseSettings.validation?.lifecycle_closure_like_actual_result_patterns ?? SETTINGS_DEFAULTS.validation.lifecycle_closure_like_actual_result_patterns),
+    estimate_defaults_by_type: normalizeEstimateDefaultOverrides(baseSettings.validation?.estimate_defaults_by_type)
+  };
+}
+function buildSerializedSearchSettings(baseSettings) {
+  return {
+    ...SETTINGS_DEFAULTS.search,
+    ...baseSettings.search,
+    mutation_refresh_policy: normalizeSearchMutationRefreshPolicy(baseSettings.search?.mutation_refresh_policy),
+    query_expansion: {
+      ...SETTINGS_DEFAULTS.search.query_expansion,
+      ...baseSettings.search?.query_expansion,
+      enabled: normalizeSearchQueryExpansionEnabled(baseSettings.search?.query_expansion?.enabled),
+      provider: normalizeSearchQueryExpansionProvider(baseSettings.search?.query_expansion?.provider)
+    },
+    rerank: {
+      ...SETTINGS_DEFAULTS.search.rerank,
+      ...baseSettings.search?.rerank,
+      enabled: normalizeSearchRerankEnabled(baseSettings.search?.rerank?.enabled),
+      model: normalizeSearchRerankModel(baseSettings.search?.rerank?.model),
+      top_k: normalizeSearchRerankTopK(baseSettings.search?.rerank?.top_k)
+    }
+  };
+}
+function buildSerializedContextSettings(baseSettings) {
+  return {
+    default_depth: baseSettings.context?.default_depth ?? SETTINGS_DEFAULTS.context.default_depth,
+    activity_limit: baseSettings.context?.activity_limit ?? SETTINGS_DEFAULTS.context.activity_limit,
+    stale_threshold_days: baseSettings.context?.stale_threshold_days ?? SETTINGS_DEFAULTS.context.stale_threshold_days,
+    sections: {
+      ...SETTINGS_DEFAULTS.context.sections,
+      ...baseSettings.context?.sections
+    }
+  };
+}
+function buildSerializedVectorStoreSettings(baseSettings) {
+  return {
+    ...baseSettings.vector_store,
+    adapter: baseSettings.vector_store?.adapter ?? SETTINGS_DEFAULTS.vector_store.adapter,
+    collection_name: normalizeVectorStoreCollectionName(baseSettings.vector_store?.collection_name),
+    qdrant: { ...baseSettings.vector_store?.qdrant },
+    lancedb: { ...baseSettings.vector_store?.lancedb }
+  };
+}
+function buildNormalizedSettingsForSerialization(baseSettings, governance, normalizedSchema, persistedFileBackedSections) {
+  return {
+    ...baseSettings,
+    item_format: "toon",
+    validation: buildSerializedValidationSettings(baseSettings, governance),
+    governance,
+    agent_guidance: normalizeAgentGuidanceSettings(baseSettings.agent_guidance),
+    item_types: {
+      definitions: persistedFileBackedSections.item_type_definitions
+    },
+    schema: {
+      ...normalizedSchema,
+      statuses: persistedFileBackedSections.schema_statuses,
+      fields: persistedFileBackedSections.schema_fields,
+      type_workflows: persistedFileBackedSections.schema_type_workflows
+    },
+    search: buildSerializedSearchSettings(baseSettings),
+    context: buildSerializedContextSettings(baseSettings),
+    extensions: {
+      enabled: normalizeStringList2(baseSettings.extensions?.enabled),
+      disabled: normalizeStringList2(baseSettings.extensions?.disabled),
+      policy: normalizeExtensionPolicySettings(baseSettings.extensions?.policy)
+    },
+    vector_store: buildSerializedVectorStoreSettings(baseSettings)
+  };
+}
+function serializeSettings(settings, options = {}) {
+  const baseSettings = buildSerializeBaseSettings(settings);
+  const governance = resolveGovernanceKnobs(baseSettings);
+  const normalizedSchema = normalizeRuntimeSchemaSettings(baseSettings.schema);
+  const persistedFileBackedSections = resolvePersistedFileBackedSchemaSections(baseSettings, options.persist_source);
+  const normalizedSettings = buildNormalizedSettingsForSerialization(baseSettings, governance, normalizedSchema, persistedFileBackedSections);
+  const ordered = orderObject({
+    ...normalizedSettings,
+    governance: normalizeGovernanceForPersist(governance)
+  }, [
+    "version",
+    "id_prefix",
+    "author_default",
+    "item_format",
+    "locks",
+    "checkpoints",
+    "output",
+    "history",
+    "validation",
+    "governance",
+    "workflow",
+    "testing",
+    "telemetry",
+    "agent_guidance",
+    "item_types",
+    "schema",
+    "context",
+    "extensions",
+    "search",
+    "providers",
+    "vector_store"
+  ]);
+  orderSerializedSettingsSections(ordered);
   return `${JSON.stringify(ordered, null, 2)}
 `;
 }
@@ -7260,6 +7370,6 @@ export {
   readSettings,
   writeSettings
 };
-//# sourceMappingURL=chunk-CY5IJMUM.js.map
+//# sourceMappingURL=chunk-I66WE2HE.js.map
 
-//# debugId=b452df4b-661b-5f08-9d20-dff37c4bfb2f
+//# debugId=a360c40f-2d95-561b-8d26-69af3a10c107