@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/config-V57QD47V.js

@@ -1,1065 +0,0 @@
-
-!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]="4d93286c-53d9-50b7-97c8-dfb21bc42622")}catch(e){}}();
-import {
-  migrateItemFilesToFormat
-} from "./chunk-ZCJAA3JK.js";
-import {
-  normalizeParentReferencePolicy,
-  normalizeSprintReleaseFormatPolicy
-} from "./chunk-7MDXZAZS.js";
-import {
-  NESTED_SETTING_DESCRIPTORS,
-  parseNestedSettingValue,
-  readNestedSettingValue,
-  resolveNestedSettingDescriptor,
-  writeNestedSettingValue
-} from "./chunk-7LQKVMPA.js";
-import "./chunk-HK72NWAD.js";
-import "./chunk-FJRKQREY.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
-  readSettingsWithMetadata,
-  writeSettings
-} from "./chunk-US3T3W5J.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-NER3KUUS.js";
-import "./chunk-NNHHXJB2.js";
-import {
-  CONTEXT_DEPTH_VALUES,
-  EXIT_CODE,
-  getSettingsPath,
-  pathExists,
-  resolveGlobalPmRoot,
-  resolveItemTypeRegistry,
-  resolveItemTypesFilePath,
-  resolvePmRoot,
-  resolveTypeName
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/config/positional-value.js
-var FORMAT_KEYS = /* @__PURE__ */ new Set(["item_format"]);
-var CRITERIA_KEYS = /* @__PURE__ */ new Set([
-  "definition_of_done",
-  "metadata_required_fields",
-  "lifecycle_stale_blocker_reason_patterns",
-  "lifecycle_closure_like_blocked_reason_patterns",
-  "lifecycle_closure_like_resolution_patterns",
-  "lifecycle_closure_like_actual_result_patterns"
-]);
-var POLICY_KEYS = /* @__PURE__ */ new Set([
-  "history_missing_stream_policy",
-  "sprint_release_format_policy",
-  "parent_reference_policy",
-  "metadata_validation_profile",
-  "governance_preset",
-  "governance_ownership_enforcement",
-  "governance_create_mode_default",
-  "governance_close_validation_default",
-  "governance_require_close_reason",
-  "governance_create_default_type",
-  "governance_workflow_enforcement",
-  "governance_parent_reference_policy",
-  "governance_metadata_validation_profile",
-  "governance_force_required_for_stale_lock",
-  "test_result_tracking",
-  "telemetry_tracking"
-]);
-var ENABLED_DISABLED_POLICY_KEYS = /* @__PURE__ */ new Set([
-  "governance_require_close_reason",
-  "governance_force_required_for_stale_lock",
-  "test_result_tracking",
-  "telemetry_tracking"
-]);
-var ENABLED_DISABLED_SYNONYMS = {
-  off: "disabled",
-  on: "enabled",
-  true: "enabled",
-  false: "disabled",
-  enabled: "enabled",
-  disabled: "disabled"
-};
-function toCanonicalKey(keyOrAlias) {
-  const normalized = keyOrAlias.trim().toLowerCase().replaceAll("-", "_");
-  if (FORMAT_KEYS.has(normalized) || CRITERIA_KEYS.has(normalized) || POLICY_KEYS.has(normalized) || normalized === "context") {
-    return normalized;
-  }
-  return void 0;
-}
-function normalizeEnabledDisabled(value) {
-  const normalized = value.trim().toLowerCase();
-  return ENABLED_DISABLED_SYNONYMS[normalized] ?? value;
-}
-function resolveConfigPositionalValue(canonicalKeyOrAlias, value) {
-  const key = toCanonicalKey(canonicalKeyOrAlias);
-  if (key === void 0) {
-    return {
-      routable: false,
-      reason: `Unknown config key "${canonicalKeyOrAlias}" cannot route a positional value.`
-    };
-  }
-  if (key === "context") {
-    return {
-      routable: false,
-      reason: "Config set context does not accept a positional value. Use --default-depth, --activity-limit, --stale-threshold-days, or --section-<name> flags."
-    };
-  }
-  if (FORMAT_KEYS.has(key)) {
-    return { routable: true, flag: "format", value };
-  }
-  if (CRITERIA_KEYS.has(key)) {
-    return { routable: true, flag: "criterion", values: [value] };
-  }
-  const policyValue = ENABLED_DISABLED_POLICY_KEYS.has(key) ? normalizeEnabledDisabled(value) : value;
-  return { routable: true, flag: "policy", value: policyValue };
-}
-
-// dist/cli/commands/config.js
-var CONFIG_SCOPE_VALUES = ["project", "global"];
-var CONFIG_KEY_ALIASES = {
-  definition_of_done: ["definition-of-done", "definition_of_done"],
-  item_format: ["item-format", "item_format"],
-  history_missing_stream_policy: ["history-missing-stream-policy", "history_missing_stream_policy"],
-  sprint_release_format_policy: ["sprint-release-format-policy", "sprint_release_format_policy"],
-  parent_reference_policy: ["parent-reference-policy", "parent_reference_policy"],
-  metadata_validation_profile: ["metadata-validation-profile", "metadata_validation_profile"],
-  metadata_required_fields: ["metadata-required-fields", "metadata_required_fields"],
-  lifecycle_stale_blocker_reason_patterns: [
-    "lifecycle-stale-blocker-reason-patterns",
-    "lifecycle_stale_blocker_reason_patterns"
-  ],
-  lifecycle_closure_like_blocked_reason_patterns: [
-    "lifecycle-closure-like-blocked-reason-patterns",
-    "lifecycle_closure_like_blocked_reason_patterns"
-  ],
-  lifecycle_closure_like_resolution_patterns: [
-    "lifecycle-closure-like-resolution-patterns",
-    "lifecycle_closure_like_resolution_patterns"
-  ],
-  lifecycle_closure_like_actual_result_patterns: [
-    "lifecycle-closure-like-actual-result-patterns",
-    "lifecycle_closure_like_actual_result_patterns"
-  ],
-  governance_preset: ["governance-preset", "governance_preset"],
-  governance_ownership_enforcement: ["governance-ownership-enforcement", "governance_ownership_enforcement"],
-  governance_create_mode_default: ["governance-create-mode-default", "governance_create_mode_default"],
-  governance_close_validation_default: [
-    "governance-close-validation-default",
-    "governance_close_validation_default"
-  ],
-  governance_require_close_reason: [
-    "governance-require-close-reason",
-    "governance_require_close_reason"
-  ],
-  governance_create_default_type: ["governance-create-default-type", "governance_create_default_type"],
-  governance_workflow_enforcement: ["governance-workflow-enforcement", "governance_workflow_enforcement"],
-  governance_parent_reference_policy: ["governance-parent-reference-policy", "governance_parent_reference_policy"],
-  governance_metadata_validation_profile: [
-    "governance-metadata-validation-profile",
-    "governance_metadata_validation_profile"
-  ],
-  governance_force_required_for_stale_lock: [
-    "governance-force-required-for-stale-lock",
-    "governance_force_required_for_stale_lock"
-  ],
-  test_result_tracking: ["test-result-tracking", "test_result_tracking"],
-  telemetry_tracking: ["telemetry-tracking", "telemetry_tracking"],
-  context: ["context"]
-};
-var CANONICAL_CONFIG_KEYS = Object.keys(CONFIG_KEY_ALIASES).map((candidate) => CONFIG_KEY_ALIASES[candidate][0]);
-var CONFIG_KEY_BY_ALIAS = Object.fromEntries(Object.keys(CONFIG_KEY_ALIASES).flatMap((key) => CONFIG_KEY_ALIASES[key].map((alias) => [alias, key])));
-var CONFIG_KEY_SUMMARIES = {
-  definition_of_done: "Definition of Done criteria list.",
-  item_format: "Default item file format.",
-  history_missing_stream_policy: "Missing history stream handling policy.",
-  sprint_release_format_policy: "Sprint/release format validation policy.",
-  parent_reference_policy: "Parent reference validation policy.",
-  metadata_validation_profile: "Validate metadata profile policy (core|strict|custom).",
-  metadata_required_fields: "Validate custom metadata required-fields list.",
-  lifecycle_stale_blocker_reason_patterns: "Validate lifecycle stale-blocker reason substring patterns (criteria list).",
-  lifecycle_closure_like_blocked_reason_patterns: "Validate lifecycle closure-like blocked_reason substring patterns (criteria list).",
-  lifecycle_closure_like_resolution_patterns: "Validate lifecycle closure-like resolution substring patterns (criteria list).",
-  lifecycle_closure_like_actual_result_patterns: "Validate lifecycle closure-like actual_result substring patterns (criteria list).",
-  governance_preset: "Governance preset policy (minimal|default|strict|custom).",
-  governance_ownership_enforcement: "Governance ownership enforcement policy (none|warn|strict).",
-  governance_create_mode_default: "Governance default create mode (progressive|strict).",
-  governance_close_validation_default: "Governance default close validation mode (off|warn|strict).",
-  governance_require_close_reason: "Governance close-reason requirement policy (enabled|disabled).",
-  governance_create_default_type: "Governance default item type for `pm create` when --type is omitted.",
-  governance_workflow_enforcement: "Governance per-type transition enforcement mode (off|warn|strict).",
-  governance_parent_reference_policy: "Governance parent reference policy (warn|strict_error).",
-  governance_metadata_validation_profile: "Governance metadata validation profile (core|strict|custom).",
-  governance_force_required_for_stale_lock: "Governance stale-lock force policy (enabled|disabled).",
-  test_result_tracking: "Item-level linked test result persistence policy.",
-  telemetry_tracking: "Telemetry usage reporting policy.",
-  context: "Context command settings (depth, section toggles, limits)."
-};
-var LIFECYCLE_PATTERN_CONFIG_KEYS = [
-  "lifecycle_stale_blocker_reason_patterns",
-  "lifecycle_closure_like_blocked_reason_patterns",
-  "lifecycle_closure_like_resolution_patterns",
-  "lifecycle_closure_like_actual_result_patterns"
-];
-var CRITERIA_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "metadata_required_fields",
-  ...LIFECYCLE_PATTERN_CONFIG_KEYS
-]);
-var TRACKING_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "test_result_tracking",
-  "telemetry_tracking"
-]);
-var GOVERNANCE_BOOLEAN_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "governance_require_close_reason",
-  "governance_force_required_for_stale_lock"
-]);
-var GOVERNANCE_POLICY_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "governance_ownership_enforcement",
-  "governance_create_mode_default",
-  "governance_close_validation_default"
-]);
-var GOVERNANCE_VALIDATION_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "governance_parent_reference_policy",
-  "governance_metadata_validation_profile",
-  "governance_workflow_enforcement"
-]);
-var GOVERNANCE_PRESET_OR_TYPE_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "governance_preset",
-  "governance_create_default_type"
-]);
-var isCriteriaValueConfigKey = (key) => CRITERIA_CONFIG_KEYS.has(key);
-var isGovernancePolicyConfigKey = (key) => GOVERNANCE_POLICY_CONFIG_KEYS.has(key);
-var isGovernanceValidationConfigKey = (key) => GOVERNANCE_VALIDATION_CONFIG_KEYS.has(key);
-var isGovernancePresetOrTypeConfigKey = (key) => GOVERNANCE_PRESET_OR_TYPE_CONFIG_KEYS.has(key);
-function isCriteriaConfigKey(key) {
-  return key === "definition_of_done" || isCriteriaValueConfigKey(key);
-}
-function normalizeScope(value) {
-  if (CONFIG_SCOPE_VALUES.includes(value)) {
-    return value;
-  }
-  throw new PmCliError(`Invalid config scope "${value}". Allowed: ${CONFIG_SCOPE_VALUES.join(", ")}`, EXIT_CODE.USAGE);
-}
-function normalizeAction(value) {
-  if (value === "get" || value === "set" || value === "list" || value === "export") {
-    return value;
-  }
-  throw new PmCliError(`Invalid config action "${value}". Allowed: get, set, list, export`, EXIT_CODE.USAGE);
-}
-function normalizeKey(value) {
-  const key = CONFIG_KEY_BY_ALIAS[value];
-  if (key) {
-    return key;
-  }
-  const nestedKeys = NESTED_SETTING_DESCRIPTORS.map((descriptor) => descriptor.key).join(", ");
-  throw new PmCliError(`Invalid config key "${value}". Supported: ${CANONICAL_CONFIG_KEYS.join(", ")} (underscore variants also accepted). Nested leaf settings: ${nestedKeys}.`, EXIT_CODE.USAGE);
-}
-function normalizeCriteria(values, clearCriteria) {
-  const normalized = [...new Set((values ?? []).map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-  if (clearCriteria) {
-    if (normalized.length > 0) {
-      throw new PmCliError("Config set definition-of-done cannot combine --clear-criteria with --criterion values", EXIT_CODE.USAGE);
-    }
-    return [];
-  }
-  if (normalized.length === 0) {
-    throw new PmCliError("Config set definition-of-done requires at least one non-empty --criterion value (or --clear-criteria to clear)", EXIT_CODE.USAGE);
-  }
-  return normalized;
-}
-function normalizeItemFormat(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === "toon") {
-    return "toon";
-  }
-  if (normalized === "json_markdown") {
-    throw new PmCliError("Config set item-format no longer accepts json_markdown. Markdown item files are legacy read/migration input only.", EXIT_CODE.USAGE);
-  }
-  throw new PmCliError("Config set item-format requires --format toon", EXIT_CODE.USAGE);
-}
-function normalizeHistoryMissingStreamPolicy(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "auto_create" || normalized === "strict_error") {
-    return normalized;
-  }
-  throw new PmCliError("Config set history-missing-stream-policy requires --policy with one of: auto_create, strict_error", EXIT_CODE.USAGE);
-}
-function normalizeTestResultTrackingPolicy(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "enabled" || normalized === "disabled") {
-    return normalized;
-  }
-  throw new PmCliError("Config set test-result-tracking requires --policy with one of: enabled, disabled", EXIT_CODE.USAGE);
-}
-function normalizeTelemetryTrackingPolicy(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "enabled" || normalized === "disabled") {
-    return normalized;
-  }
-  throw new PmCliError("Config set telemetry-tracking requires --policy with one of: enabled, disabled", EXIT_CODE.USAGE);
-}
-function normalizeValidateMetadataProfile(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "core" || normalized === "strict" || normalized === "custom") {
-    return normalized;
-  }
-  throw new PmCliError("Config set metadata-validation-profile requires --policy with one of: core, strict, custom", EXIT_CODE.USAGE);
-}
-function normalizeGovernancePreset(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "minimal" || normalized === "default" || normalized === "strict" || normalized === "custom") {
-    return normalized;
-  }
-  throw new PmCliError("Config set governance-preset requires --policy with one of: minimal, default, strict, custom", EXIT_CODE.USAGE);
-}
-function normalizeGovernanceOwnershipEnforcement(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "none" || normalized === "warn" || normalized === "strict") {
-    return normalized;
-  }
-  throw new PmCliError("Config set governance-ownership-enforcement requires --policy with one of: none, warn, strict", EXIT_CODE.USAGE);
-}
-function normalizeGovernanceCreateModeDefault(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "progressive" || normalized === "strict") {
-    return normalized;
-  }
-  throw new PmCliError("Config set governance-create-mode-default requires --policy with one of: progressive, strict", EXIT_CODE.USAGE);
-}
-function normalizeGovernanceCloseValidationDefault(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "off" || normalized === "warn" || normalized === "strict") {
-    return normalized;
-  }
-  if (normalized === "none" || normalized === "disabled") {
-    return "off";
-  }
-  throw new PmCliError("Config set governance-close-validation-default requires --policy with one of: off, warn, strict", EXIT_CODE.USAGE);
-}
-function normalizeGovernanceWorkflowEnforcement(value) {
-  const normalized = typeof value === "string" ? value.trim().toLowerCase().replaceAll("-", "_") : void 0;
-  if (normalized === "off" || normalized === "warn" || normalized === "strict") {
-    return normalized;
-  }
-  if (normalized === "none" || normalized === "disabled") {
-    return "off";
-  }
-  throw new PmCliError("Config set governance-workflow-enforcement requires one of: off, warn, strict", EXIT_CODE.USAGE);
-}
-function normalizeGovernanceForceRequiredForStaleLockPolicy(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "enabled" || normalized === "disabled") {
-    return normalized;
-  }
-  throw new PmCliError("Config set governance-force-required-for-stale-lock requires --policy with one of: enabled, disabled", EXIT_CODE.USAGE);
-}
-function normalizeGovernanceRequireCloseReasonPolicy(value) {
-  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
-  if (normalized === "enabled" || normalized === "disabled") {
-    return normalized;
-  }
-  throw new PmCliError("Config set governance-require-close-reason requires --policy with one of: enabled, disabled", EXIT_CODE.USAGE);
-}
-function normalizePolicyForConflict(key, value) {
-  switch (key) {
-    case "history_missing_stream_policy":
-      return normalizeHistoryMissingStreamPolicy(value);
-    case "sprint_release_format_policy":
-      return normalizeSprintReleaseFormatPolicy(value);
-    case "parent_reference_policy":
-    case "governance_parent_reference_policy":
-      return normalizeParentReferencePolicy(value);
-    case "metadata_validation_profile":
-    case "governance_metadata_validation_profile":
-      return normalizeValidateMetadataProfile(value);
-    case "governance_preset":
-      return normalizeGovernancePreset(value);
-    case "governance_ownership_enforcement":
-      return normalizeGovernanceOwnershipEnforcement(value);
-    case "governance_create_mode_default":
-      return normalizeGovernanceCreateModeDefault(value);
-    case "governance_close_validation_default":
-      return normalizeGovernanceCloseValidationDefault(value);
-    case "governance_require_close_reason":
-      return normalizeGovernanceRequireCloseReasonPolicy(value);
-    case "governance_workflow_enforcement":
-      return normalizeGovernanceWorkflowEnforcement(value);
-    case "governance_force_required_for_stale_lock":
-      return normalizeGovernanceForceRequiredForStaleLockPolicy(value);
-    case "test_result_tracking":
-      return normalizeTestResultTrackingPolicy(value);
-    case "telemetry_tracking":
-      return normalizeTelemetryTrackingPolicy(value);
-    default:
-      return value.trim().toLowerCase().replaceAll("-", "_");
-  }
-}
-var METADATA_REQUIRED_FIELD_ALIAS_MAP = {
-  author: "author",
-  acceptance_criteria: "acceptance_criteria",
-  "acceptance-criteria": "acceptance_criteria",
-  estimated_minutes: "estimated_minutes",
-  "estimated-minutes": "estimated_minutes",
-  estimate: "estimated_minutes",
-  close_reason: "close_reason",
-  "close-reason": "close_reason",
-  reviewer: "reviewer",
-  risk: "risk",
-  confidence: "confidence",
-  sprint: "sprint",
-  release: "release"
-};
-var METADATA_REQUIRED_FIELD_OPTIONS = [
-  "author",
-  "acceptance_criteria",
-  "estimated_minutes",
-  "close_reason",
-  "reviewer",
-  "risk",
-  "confidence",
-  "sprint",
-  "release"
-];
-function normalizeMetadataRequiredFields(values, clearCriteria) {
-  const normalized = [...new Set((values ?? []).map((value) => value.trim()).filter((value) => value.length > 0))];
-  if (clearCriteria) {
-    if (normalized.length > 0) {
-      throw new PmCliError("Config set metadata-required-fields cannot combine --clear-criteria with --criterion values", EXIT_CODE.USAGE);
-    }
-    return [];
-  }
-  if (normalized.length === 0) {
-    throw new PmCliError("Config set metadata-required-fields requires at least one --criterion value (or --clear-criteria to clear)", EXIT_CODE.USAGE);
-  }
-  const lowered = normalized.map((value) => value.toLowerCase().replaceAll("-", "_"));
-  const unsupported = lowered.filter((value) => METADATA_REQUIRED_FIELD_ALIAS_MAP[value] === void 0);
-  if (unsupported.length > 0) {
-    throw new PmCliError(`Config set metadata-required-fields received unsupported values: ${unsupported.join(", ")}. Supported values: ${METADATA_REQUIRED_FIELD_OPTIONS.join(", ")}`, EXIT_CODE.USAGE);
-  }
-  return [...new Set(lowered.map((value) => METADATA_REQUIRED_FIELD_ALIAS_MAP[value]))].sort((left, right) => left.localeCompare(right));
-}
-function normalizeLifecyclePatternCriteria(key, values, clearCriteria) {
-  const normalized = [...new Set((values ?? []).map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-  if (clearCriteria) {
-    if (normalized.length > 0) {
-      throw new PmCliError(`Config set ${CONFIG_KEY_ALIASES[key][0]} cannot combine --clear-criteria with --criterion values`, EXIT_CODE.USAGE);
-    }
-    return [];
-  }
-  if (normalized.length === 0) {
-    throw new PmCliError(`Config set ${CONFIG_KEY_ALIASES[key][0]} requires at least one --criterion value (or --clear-criteria to clear)`, EXIT_CODE.USAGE);
-  }
-  return normalized;
-}
-function normalizeWarnings(values) {
-  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-function normalizeKeyForAction(action, value) {
-  if (action === "list" || action === "export") {
-    if (typeof value === "string" && value.trim().length > 0) {
-      throw new PmCliError(`Config action "${action}" does not accept <key>`, EXIT_CODE.USAGE);
-    }
-    return void 0;
-  }
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new PmCliError(`Config action "${action}" requires <key>`, EXIT_CODE.USAGE);
-  }
-  return normalizeKey(value);
-}
-function assertConfigKeyDefined(key) {
-  if (!key) {
-    throw new PmCliError("Config action requires <key>", EXIT_CODE.USAGE);
-  }
-}
-var CONFIG_VALUE_READERS = {
-  definition_of_done: (settings) => [...settings.workflow.definition_of_done],
-  item_format: (settings) => settings.item_format,
-  history_missing_stream_policy: (settings) => settings.history.missing_stream,
-  sprint_release_format_policy: (settings) => settings.validation.sprint_release_format,
-  parent_reference_policy: (settings) => settings.validation.parent_reference,
-  metadata_validation_profile: (settings) => settings.validation.metadata_profile,
-  metadata_required_fields: (settings) => [...settings.validation.metadata_required_fields],
-  lifecycle_stale_blocker_reason_patterns: (settings) => [
-    ...settings.validation.lifecycle_stale_blocker_reason_patterns
-  ],
-  lifecycle_closure_like_blocked_reason_patterns: (settings) => [
-    ...settings.validation.lifecycle_closure_like_blocked_reason_patterns
-  ],
-  lifecycle_closure_like_resolution_patterns: (settings) => [
-    ...settings.validation.lifecycle_closure_like_resolution_patterns
-  ],
-  lifecycle_closure_like_actual_result_patterns: (settings) => [
-    ...settings.validation.lifecycle_closure_like_actual_result_patterns
-  ],
-  governance_preset: (settings) => settings.governance.preset,
-  governance_ownership_enforcement: (settings) => settings.governance.ownership_enforcement,
-  governance_create_mode_default: (settings) => settings.governance.create_mode_default,
-  governance_close_validation_default: (settings) => settings.governance.close_validation_default,
-  governance_require_close_reason: (settings) => settings.governance.require_close_reason ? "enabled" : "disabled",
-  governance_create_default_type: (settings) => settings.governance.create_default_type ?? "",
-  governance_workflow_enforcement: (settings) => settings.governance.workflow_enforcement ?? "off",
-  governance_parent_reference_policy: (settings) => settings.governance.parent_reference,
-  governance_metadata_validation_profile: (settings) => settings.governance.metadata_profile,
-  governance_force_required_for_stale_lock: (settings) => settings.governance.force_required_for_stale_lock ? "enabled" : "disabled",
-  test_result_tracking: (settings) => settings.testing.record_results_to_items ? "enabled" : "disabled",
-  telemetry_tracking: (settings) => settings.telemetry.enabled ? "enabled" : "disabled",
-  context: (settings) => ({
-    default_depth: settings.context.default_depth,
-    activity_limit: settings.context.activity_limit,
-    stale_threshold_days: settings.context.stale_threshold_days,
-    sections: { ...settings.context.sections }
-  })
-};
-function readConfigValue(settings, key) {
-  return CONFIG_VALUE_READERS[key](settings);
-}
-function withWarnings(result, warnings) {
-  if (warnings.length === 0) {
-    return result;
-  }
-  return {
-    ...result,
-    warnings
-  };
-}
-async function resolveSettingsTarget(scope, global) {
-  const cwd = process.cwd();
-  const pmRoot = scope === "project" ? resolvePmRoot(cwd, global.path) : resolveGlobalPmRoot(cwd);
-  const settingsPath = getSettingsPath(pmRoot);
-  if (scope === "project" && !await pathExists(settingsPath)) {
-    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
-  }
-  return { pmRoot, settingsPath };
-}
-function parseSectionToggle(raw) {
-  if (raw === void 0)
-    return void 0;
-  const normalized = raw.trim().toLowerCase();
-  if (normalized === "true" || normalized === "enabled" || normalized === "on" || normalized === "1")
-    return true;
-  if (normalized === "false" || normalized === "disabled" || normalized === "off" || normalized === "0")
-    return false;
-  throw new PmCliError(`Context section toggle must be true|false|enabled|disabled, got "${raw}"`, EXIT_CODE.USAGE);
-}
-async function applyContextConfig(settings, options, target, scope, warnings) {
-  let changed = false;
-  const ctx = settings.context;
-  if (options.defaultDepth !== void 0) {
-    const normalized = options.defaultDepth.trim().toLowerCase();
-    if (!CONTEXT_DEPTH_VALUES.includes(normalized)) {
-      throw new PmCliError(`Context --default-depth must be one of ${CONTEXT_DEPTH_VALUES.join("|")}`, EXIT_CODE.USAGE);
-    }
-    if (ctx.default_depth !== normalized) {
-      ctx.default_depth = normalized;
-      changed = true;
-    }
-  }
-  if (options.activityLimit !== void 0) {
-    const parsed = parseInt(options.activityLimit.trim(), 10);
-    if (isNaN(parsed) || parsed <= 0) {
-      throw new PmCliError("Context --activity-limit must be a positive integer", EXIT_CODE.USAGE);
-    }
-    if (ctx.activity_limit !== parsed) {
-      ctx.activity_limit = parsed;
-      changed = true;
-    }
-  }
-  if (options.staleThresholdDays !== void 0) {
-    const parsed = parseInt(options.staleThresholdDays.trim(), 10);
-    if (isNaN(parsed) || parsed <= 0) {
-      throw new PmCliError("Context --stale-threshold-days must be a positive integer", EXIT_CODE.USAGE);
-    }
-    if (ctx.stale_threshold_days !== parsed) {
-      ctx.stale_threshold_days = parsed;
-      changed = true;
-    }
-  }
-  const sectionToggles = [
-    ["hierarchy", options.sectionHierarchy],
-    ["activity", options.sectionActivity],
-    ["progress", options.sectionProgress],
-    ["blockers", options.sectionBlockers],
-    ["files", options.sectionFiles],
-    ["workload", options.sectionWorkload],
-    ["staleness", options.sectionStaleness],
-    ["tests", options.sectionTests]
-  ];
-  for (const [sectionName, rawValue] of sectionToggles) {
-    const toggle = parseSectionToggle(rawValue);
-    if (toggle !== void 0) {
-      const key = sectionName;
-      if (ctx.sections[key] !== toggle) {
-        ctx.sections[key] = toggle;
-        changed = true;
-      }
-    }
-  }
-  if (changed) {
-    await writeSettings(target.pmRoot, settings, "config:set:context");
-  }
-  return withWarnings({
-    scope,
-    key: "context",
-    context_settings: {
-      default_depth: ctx.default_depth,
-      activity_limit: ctx.activity_limit,
-      stale_threshold_days: ctx.stale_threshold_days,
-      sections: { ...ctx.sections }
-    },
-    settings_path: target.settingsPath,
-    changed
-  }, warnings);
-}
-function applyNestedSettingPositionalValue(keyValue, valueValue, options) {
-  if (options.value !== void 0 && options.value !== valueValue) {
-    throw new PmCliError(`Config set ${keyValue} received both positional value "${valueValue}" and --value "${options.value}". Pass only one.`, EXIT_CODE.USAGE);
-  }
-  return { ...options, value: valueValue };
-}
-function applyPositionalValue(action, keyValue, normalizedKey, nestedSetting, valueValue, options) {
-  if (valueValue === void 0) {
-    return options;
-  }
-  if (action !== "set") {
-    throw new PmCliError(`Config action "${action}" does not accept a positional value. Only "set" takes <value>.`, EXIT_CODE.USAGE);
-  }
-  if (typeof keyValue !== "string" || keyValue.trim().length === 0) {
-    throw new PmCliError('Config action "set" requires <key> before a positional <value>.', EXIT_CODE.USAGE);
-  }
-  if (nestedSetting) {
-    return applyNestedSettingPositionalValue(keyValue, valueValue, options);
-  }
-  assertConfigKeyDefined(normalizedKey);
-  const routed = resolveConfigPositionalValue(normalizedKey, valueValue);
-  if (!routed.routable) {
-    throw new PmCliError(routed.reason, EXIT_CODE.USAGE);
-  }
-  if (routed.flag === "criterion") {
-    if (options.criterion !== void 0 && options.criterion.length > 0) {
-      throw new PmCliError(`Config set ${keyValue} received both positional value "${valueValue}" and --criterion. Pass criteria via --criterion only when supplying more than one value.`, EXIT_CODE.USAGE);
-    }
-    return { ...options, criterion: routed.values };
-  }
-  if (routed.flag === "format") {
-    if (options.format !== void 0 && normalizeItemFormat(options.format) !== normalizeItemFormat(routed.value)) {
-      throw new PmCliError(`Config set ${keyValue} received both positional value "${valueValue}" and --format "${options.format}". Pass only one.`, EXIT_CODE.USAGE);
-    }
-    return { ...options, format: routed.value };
-  }
-  if (options.policy !== void 0 && normalizePolicyForConflict(normalizedKey, options.policy) !== normalizePolicyForConflict(normalizedKey, routed.value)) {
-    throw new PmCliError(`Config set ${keyValue} received both positional value "${valueValue}" and --policy "${options.policy}". Pass only one.`, EXIT_CODE.USAGE);
-  }
-  return { ...options, policy: routed.value };
-}
-function buildConfigListResult(context) {
-  const keys = Object.keys(CONFIG_KEY_ALIASES).map((candidate) => ({
-    key: candidate,
-    aliases: CONFIG_KEY_ALIASES[candidate],
-    value_kind: candidate === "context" ? "object" : isCriteriaConfigKey(candidate) ? "string_array" : "enum",
-    set_flags: candidate === "context" ? ["--default-depth", "--activity-limit", "--stale-threshold-days", "--section-<name>"] : isCriteriaConfigKey(candidate) ? ["--criterion", "--clear-criteria"] : candidate === "item_format" ? ["--format"] : ["--policy"],
-    summary: CONFIG_KEY_SUMMARIES[candidate],
-    value: readConfigValue(context.settings, candidate)
-  }));
-  const nestedSettings = NESTED_SETTING_DESCRIPTORS.map((descriptor) => ({
-    key: descriptor.key,
-    path: descriptor.path,
-    kind: descriptor.kind,
-    value: readNestedSettingValue(context.settings, descriptor)
-  }));
-  return withWarnings({
-    scope: context.scope,
-    keys,
-    nested_settings: nestedSettings,
-    count: keys.length,
-    settings_path: context.target.settingsPath,
-    changed: false
-  }, context.warnings);
-}
-function buildConfigExportResult(context) {
-  const values = Object.fromEntries(Object.keys(CONFIG_KEY_ALIASES).map((key) => [key, readConfigValue(context.settings, key)]));
-  return withWarnings({
-    scope: context.scope,
-    values,
-    settings_path: context.target.settingsPath,
-    changed: false
-  }, context.warnings);
-}
-function buildConfigGetResult(context, key) {
-  const value = readConfigValue(context.settings, key);
-  const base = {
-    scope: context.scope,
-    key,
-    settings_path: context.target.settingsPath,
-    changed: false
-  };
-  if (key === "item_format") {
-    return withWarnings({
-      ...base,
-      format: context.settings.item_format,
-      has_explicit_item_format: context.metadata.has_explicit_item_format
-    }, context.warnings);
-  }
-  if (key === "context") {
-    return withWarnings({ ...base, context_settings: value }, context.warnings);
-  }
-  if (Array.isArray(value)) {
-    return withWarnings({ ...base, criteria: value }, context.warnings);
-  }
-  return withWarnings({ ...base, policy: value }, context.warnings);
-}
-async function buildNestedSettingResult(context, action, nestedSetting, options) {
-  if (action === "get") {
-    const currentValue = readNestedSettingValue(context.settings, nestedSetting);
-    return withWarnings({
-      scope: context.scope,
-      key: nestedSetting.key,
-      nested_setting: {
-        key: nestedSetting.key,
-        path: nestedSetting.path,
-        kind: nestedSetting.kind,
-        value: currentValue
-      },
-      settings_path: context.target.settingsPath,
-      changed: false
-    }, context.warnings);
-  }
-  const rawValue = options.value;
-  if (typeof rawValue !== "string") {
-    throw new PmCliError(`Config set ${nestedSetting.key} requires a value. Pass it positionally (\`pm config ${context.scope} set ${nestedSetting.key} <value>\`) or via --value.`, EXIT_CODE.USAGE);
-  }
-  const parsed = parseNestedSettingValue(nestedSetting, rawValue);
-  if (!parsed.ok) {
-    throw new PmCliError(parsed.error.message, EXIT_CODE.USAGE);
-  }
-  const changed = writeNestedSettingValue(context.settings, nestedSetting, parsed.parsed.value);
-  if (changed) {
-    await writeSettings(context.target.pmRoot, context.settings, `config:set:${nestedSetting.path}`);
-  }
-  return withWarnings({
-    scope: context.scope,
-    key: nestedSetting.key,
-    nested_setting: {
-      key: nestedSetting.key,
-      path: nestedSetting.path,
-      kind: nestedSetting.kind,
-      value: parsed.parsed.value
-    },
-    settings_path: context.target.settingsPath,
-    changed
-  }, context.warnings);
-}
-async function writeConfigSettingsIfChanged(context, changed, reason) {
-  if (changed) {
-    await writeSettings(context.target.pmRoot, context.settings, reason);
-  }
-}
-function hasGovernanceValidationMirrorChange(governanceValue, validationValue, nextPolicy) {
-  return governanceValue !== nextPolicy || validationValue !== nextPolicy;
-}
-function buildPolicyResult(context, key, policy, changed) {
-  return withWarnings({
-    scope: context.scope,
-    key,
-    policy,
-    settings_path: context.target.settingsPath,
-    changed
-  }, context.warnings);
-}
-function buildCriteriaResult(context, key, criteria, changed) {
-  return withWarnings({
-    scope: context.scope,
-    key,
-    criteria,
-    settings_path: context.target.settingsPath,
-    changed
-  }, context.warnings);
-}
-async function setItemFormatConfig(context, options) {
-  const nextFormat = normalizeItemFormat(options.format);
-  const changed = context.settings.item_format !== nextFormat || !context.metadata.has_explicit_item_format;
-  let migration = void 0;
-  if (changed) {
-    const typeRegistry = resolveItemTypeRegistry(context.settings, getActiveExtensionRegistrations());
-    const migrated = await migrateItemFilesToFormat(context.target.pmRoot, nextFormat, "config:set:item_format:migrate", typeRegistry.type_to_folder, context.settings.schema);
-    migration = {
-      target_format: migrated.target_format,
-      scanned: migrated.scanned,
-      migrated: migrated.migrated,
-      removed: migrated.removed,
-      warnings: migrated.warnings
-    };
-    context.settings.item_format = nextFormat;
-    await writeSettings(context.target.pmRoot, context.settings, "config:set:item_format");
-  }
-  return withWarnings({
-    scope: context.scope,
-    key: "item_format",
-    format: context.settings.item_format,
-    has_explicit_item_format: true,
-    migration,
-    settings_path: context.target.settingsPath,
-    changed
-  }, context.warnings);
-}
-async function setValidationConfig(context, key, options) {
-  if (key === "history_missing_stream_policy") {
-    const nextPolicy2 = normalizeHistoryMissingStreamPolicy(options.policy);
-    const changed2 = context.settings.history.missing_stream !== nextPolicy2;
-    context.settings.history.missing_stream = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:history_missing_stream_policy");
-    return buildPolicyResult(context, key, context.settings.history.missing_stream, changed2);
-  }
-  if (key === "sprint_release_format_policy") {
-    const nextPolicy2 = normalizeSprintReleaseFormatPolicy(options.policy);
-    const changed2 = context.settings.validation.sprint_release_format !== nextPolicy2;
-    context.settings.validation.sprint_release_format = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:sprint_release_format_policy");
-    return buildPolicyResult(context, key, context.settings.validation.sprint_release_format, changed2);
-  }
-  if (key === "parent_reference_policy") {
-    const nextPolicy2 = normalizeParentReferencePolicy(options.policy);
-    const changed2 = context.settings.validation.parent_reference !== nextPolicy2 || context.settings.governance.preset !== "custom" || context.settings.governance.parent_reference !== nextPolicy2;
-    context.settings.validation.parent_reference = nextPolicy2;
-    context.settings.governance.preset = "custom";
-    context.settings.governance.parent_reference = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:parent_reference_policy");
-    return buildPolicyResult(context, key, context.settings.validation.parent_reference, changed2);
-  }
-  const nextPolicy = normalizeValidateMetadataProfile(options.policy);
-  const changed = context.settings.validation.metadata_profile !== nextPolicy || context.settings.governance.preset !== "custom" || context.settings.governance.metadata_profile !== nextPolicy;
-  context.settings.validation.metadata_profile = nextPolicy;
-  context.settings.governance.preset = "custom";
-  context.settings.governance.metadata_profile = nextPolicy;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:metadata_validation_profile");
-  return buildPolicyResult(context, key, context.settings.validation.metadata_profile, changed);
-}
-async function setCriteriaConfig(context, key, options) {
-  if (key === "metadata_required_fields") {
-    const nextCriteria2 = normalizeMetadataRequiredFields(options.criterion, options.clearCriteria);
-    const changed2 = nextCriteria2.length !== context.settings.validation.metadata_required_fields.length || nextCriteria2.some((value, index) => value !== context.settings.validation.metadata_required_fields[index]);
-    context.settings.validation.metadata_required_fields = nextCriteria2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:metadata_required_fields");
-    return buildCriteriaResult(context, key, [...context.settings.validation.metadata_required_fields], changed2);
-  }
-  const lifecycleTargets = {
-    lifecycle_stale_blocker_reason_patterns: context.settings.validation.lifecycle_stale_blocker_reason_patterns,
-    lifecycle_closure_like_blocked_reason_patterns: context.settings.validation.lifecycle_closure_like_blocked_reason_patterns,
-    lifecycle_closure_like_resolution_patterns: context.settings.validation.lifecycle_closure_like_resolution_patterns,
-    lifecycle_closure_like_actual_result_patterns: context.settings.validation.lifecycle_closure_like_actual_result_patterns
-  };
-  const currentCriteria = lifecycleTargets[key];
-  const nextCriteria = normalizeLifecyclePatternCriteria(key, options.criterion, options.clearCriteria);
-  const changed = nextCriteria.length !== currentCriteria.length || nextCriteria.some((value, index) => value !== currentCriteria[index]);
-  currentCriteria.splice(0, currentCriteria.length, ...nextCriteria);
-  await writeConfigSettingsIfChanged(context, changed, `config:set:${key}`);
-  return buildCriteriaResult(context, key, [...currentCriteria], changed);
-}
-async function setGovernancePresetOrTypeConfig(context, key, options) {
-  if (key === "governance_preset") {
-    const nextPolicy = normalizeGovernancePreset(options.policy);
-    const changed2 = context.settings.governance.preset !== nextPolicy;
-    context.settings.governance.preset = nextPolicy;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_preset");
-    return buildPolicyResult(context, key, context.settings.governance.preset, changed2);
-  }
-  const policyProvided = typeof options.policy === "string";
-  const rawType = policyProvided ? options.policy.trim() : "";
-  if (policyProvided && rawType.length === 0) {
-    const changed2 = context.settings.governance.create_default_type !== void 0;
-    delete context.settings.governance.create_default_type;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_create_default_type");
-    return buildPolicyResult(context, key, context.settings.governance.create_default_type ?? "", changed2);
-  }
-  if (rawType.length === 0) {
-    throw new PmCliError('Config set governance-create-default-type requires an item type value (or an empty value "" to clear it)', EXIT_CODE.USAGE);
-  }
-  const typeRegistry = resolveItemTypeRegistry(context.settings, getActiveExtensionRegistrations());
-  const resolvedType = resolveTypeName(rawType, typeRegistry);
-  if (!resolvedType) {
-    throw new PmCliError(buildInvalidTypeError(rawType, typeRegistry.types, resolveItemTypesFilePath(context.target.pmRoot, context.settings.schema)), EXIT_CODE.USAGE);
-  }
-  const changed = context.settings.governance.create_default_type !== resolvedType;
-  context.settings.governance.create_default_type = resolvedType;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:governance_create_default_type");
-  return buildPolicyResult(context, key, context.settings.governance.create_default_type, changed);
-}
-async function setGovernancePolicyConfig(context, key, options) {
-  if (key === "governance_ownership_enforcement") {
-    const nextPolicy2 = normalizeGovernanceOwnershipEnforcement(options.policy);
-    const changed2 = context.settings.governance.preset !== "custom" || context.settings.governance.ownership_enforcement !== nextPolicy2;
-    context.settings.governance.preset = "custom";
-    context.settings.governance.ownership_enforcement = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_ownership_enforcement");
-    return buildPolicyResult(context, key, context.settings.governance.ownership_enforcement, changed2);
-  }
-  if (key === "governance_create_mode_default") {
-    const nextPolicy2 = normalizeGovernanceCreateModeDefault(options.policy);
-    const changed2 = context.settings.governance.preset !== "custom" || context.settings.governance.create_mode_default !== nextPolicy2;
-    context.settings.governance.preset = "custom";
-    context.settings.governance.create_mode_default = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_create_mode_default");
-    return buildPolicyResult(context, key, context.settings.governance.create_mode_default, changed2);
-  }
-  const nextPolicy = normalizeGovernanceCloseValidationDefault(options.policy);
-  const changed = context.settings.governance.preset !== "custom" || context.settings.governance.close_validation_default !== nextPolicy;
-  context.settings.governance.preset = "custom";
-  context.settings.governance.close_validation_default = nextPolicy;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:governance_close_validation_default");
-  return buildPolicyResult(context, key, context.settings.governance.close_validation_default, changed);
-}
-async function setGovernanceValidationConfig(context, key, options) {
-  if (key === "governance_parent_reference_policy") {
-    const nextPolicy2 = normalizeParentReferencePolicy(options.policy);
-    const changed2 = context.settings.governance.preset !== "custom" || hasGovernanceValidationMirrorChange(context.settings.governance.parent_reference, context.settings.validation.parent_reference, nextPolicy2);
-    context.settings.governance.preset = "custom";
-    context.settings.governance.parent_reference = nextPolicy2;
-    context.settings.validation.parent_reference = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_parent_reference_policy");
-    return buildPolicyResult(context, key, context.settings.governance.parent_reference, changed2);
-  }
-  if (key === "governance_metadata_validation_profile") {
-    const nextPolicy2 = normalizeValidateMetadataProfile(options.policy);
-    const changed2 = context.settings.governance.preset !== "custom" || hasGovernanceValidationMirrorChange(context.settings.governance.metadata_profile, context.settings.validation.metadata_profile, nextPolicy2);
-    context.settings.governance.preset = "custom";
-    context.settings.governance.metadata_profile = nextPolicy2;
-    context.settings.validation.metadata_profile = nextPolicy2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_metadata_validation_profile");
-    return buildPolicyResult(context, key, context.settings.governance.metadata_profile, changed2);
-  }
-  const nextPolicy = normalizeGovernanceWorkflowEnforcement(options.policy);
-  const changed = (context.settings.governance.workflow_enforcement ?? "off") !== nextPolicy;
-  context.settings.governance.workflow_enforcement = nextPolicy;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:governance_workflow_enforcement");
-  return buildPolicyResult(context, key, context.settings.governance.workflow_enforcement, changed);
-}
-async function setGovernanceBooleanConfig(context, key, options) {
-  if (key === "governance_require_close_reason") {
-    const nextPolicy2 = normalizeGovernanceRequireCloseReasonPolicy(options.policy);
-    const nextEnabled2 = nextPolicy2 === "enabled";
-    const changed2 = context.settings.governance.require_close_reason !== nextEnabled2;
-    context.settings.governance.require_close_reason = nextEnabled2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:governance_require_close_reason");
-    return buildPolicyResult(context, key, context.settings.governance.require_close_reason ? "enabled" : "disabled", changed2);
-  }
-  const nextPolicy = normalizeGovernanceForceRequiredForStaleLockPolicy(options.policy);
-  const nextEnabled = nextPolicy === "enabled";
-  const changed = context.settings.governance.preset !== "custom" || context.settings.governance.force_required_for_stale_lock !== nextEnabled;
-  context.settings.governance.preset = "custom";
-  context.settings.governance.force_required_for_stale_lock = nextEnabled;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:governance_force_required_for_stale_lock");
-  return buildPolicyResult(context, key, context.settings.governance.force_required_for_stale_lock ? "enabled" : "disabled", changed);
-}
-async function setTrackingConfig(context, key, options) {
-  if (key === "test_result_tracking") {
-    const nextPolicy2 = normalizeTestResultTrackingPolicy(options.policy);
-    const nextEnabled2 = nextPolicy2 === "enabled";
-    const changed2 = context.settings.testing.record_results_to_items !== nextEnabled2;
-    context.settings.testing.record_results_to_items = nextEnabled2;
-    await writeConfigSettingsIfChanged(context, changed2, "config:set:test_result_tracking");
-    return buildPolicyResult(context, key, context.settings.testing.record_results_to_items ? "enabled" : "disabled", changed2);
-  }
-  const nextPolicy = normalizeTelemetryTrackingPolicy(options.policy);
-  const nextEnabled = nextPolicy === "enabled";
-  const changed = context.settings.telemetry.enabled !== nextEnabled || !context.settings.telemetry.first_run_prompt_completed;
-  context.settings.telemetry.enabled = nextEnabled;
-  context.settings.telemetry.first_run_prompt_completed = true;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:telemetry_tracking");
-  return buildPolicyResult(context, key, context.settings.telemetry.enabled ? "enabled" : "disabled", changed);
-}
-async function setDefinitionOfDoneConfig(context, key, options) {
-  const nextCriteria = normalizeCriteria(options.criterion, options.clearCriteria);
-  const changed = nextCriteria.length !== context.settings.workflow.definition_of_done.length || nextCriteria.some((value, index) => value !== context.settings.workflow.definition_of_done[index]);
-  context.settings.workflow.definition_of_done = nextCriteria;
-  await writeConfigSettingsIfChanged(context, changed, "config:set:definition_of_done");
-  return buildCriteriaResult(context, key, [...context.settings.workflow.definition_of_done], changed);
-}
-async function setConfigValue(context, key, options) {
-  if (options.clearCriteria === true && !isCriteriaConfigKey(key)) {
-    throw new PmCliError("--clear-criteria is only supported with config set criteria-list keys", EXIT_CODE.USAGE);
-  }
-  if (key === "item_format") {
-    return setItemFormatConfig(context, options);
-  }
-  if (key === "context") {
-    return applyContextConfig(context.settings, options, context.target, context.scope, context.warnings);
-  }
-  if (key === "definition_of_done") {
-    return setDefinitionOfDoneConfig(context, key, options);
-  }
-  if (isCriteriaValueConfigKey(key)) {
-    return setCriteriaConfig(context, key, options);
-  }
-  if (TRACKING_CONFIG_KEYS.has(key)) {
-    return setTrackingConfig(context, key, options);
-  }
-  if (GOVERNANCE_BOOLEAN_CONFIG_KEYS.has(key)) {
-    return setGovernanceBooleanConfig(context, key, options);
-  }
-  if (isGovernancePolicyConfigKey(key)) {
-    return setGovernancePolicyConfig(context, key, options);
-  }
-  if (isGovernanceValidationConfigKey(key)) {
-    return setGovernanceValidationConfig(context, key, options);
-  }
-  if (isGovernancePresetOrTypeConfigKey(key)) {
-    return setGovernancePresetOrTypeConfig(context, key, options);
-  }
-  return setValidationConfig(context, key, options);
-}
-async function runConfig(scopeValue, actionValue, keyValue, options, global, valueValue) {
-  const scope = normalizeScope(scopeValue);
-  const action = normalizeAction(actionValue);
-  const nestedSetting = action === "get" || action === "set" ? resolveNestedSettingDescriptor(keyValue) : void 0;
-  const key = nestedSetting ? void 0 : normalizeKeyForAction(action, keyValue);
-  const routedOptions = applyPositionalValue(action, keyValue, key, nestedSetting, valueValue, options);
-  const target = await resolveSettingsTarget(scope, global);
-  const { settings, metadata, warnings: settingsReadWarnings } = await readSettingsWithMetadata(target.pmRoot);
-  const context = {
-    scope,
-    target,
-    settings,
-    metadata,
-    warnings: normalizeWarnings(settingsReadWarnings)
-  };
-  if (nestedSetting) {
-    return buildNestedSettingResult(context, action, nestedSetting, routedOptions);
-  }
-  if (action === "list") {
-    return buildConfigListResult(context);
-  }
-  if (action === "export") {
-    return buildConfigExportResult(context);
-  }
-  assertConfigKeyDefined(key);
-  return action === "get" ? buildConfigGetResult(context, key) : setConfigValue(context, key, routedOptions);
-}
-var _testOnlyConfigCommand = {
-  hasGovernanceValidationMirrorChange,
-  applyPositionalValue,
-  normalizeAction,
-  normalizeCriteria,
-  normalizeGovernanceCloseValidationDefault,
-  normalizeGovernanceCreateModeDefault,
-  normalizeGovernanceForceRequiredForStaleLockPolicy,
-  normalizeGovernanceOwnershipEnforcement,
-  normalizeGovernancePreset,
-  normalizeGovernanceRequireCloseReasonPolicy,
-  normalizeGovernanceWorkflowEnforcement,
-  normalizeHistoryMissingStreamPolicy,
-  normalizeItemFormat,
-  normalizeKey,
-  normalizeMetadataRequiredFields,
-  normalizePolicyForConflict,
-  normalizeScope,
-  normalizeTelemetryTrackingPolicy,
-  normalizeTestResultTrackingPolicy,
-  normalizeValidateMetadataProfile,
-  normalizeWarnings
-};
-export {
-  _testOnlyConfigCommand,
-  runConfig
-};
-//# sourceMappingURL=config-V57QD47V.js.map
-
-//# debugId=4d93286c-53d9-50b7-97c8-dfb21bc42622