@unbrained/pm-cli 2026.6.30 → 2026.7.2

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

@@ -0,0 +1,1072 @@
+import {
+  NESTED_SETTING_DESCRIPTORS,
+  parseNestedSettingValue,
+  readNestedSettingValue,
+  resolveNestedSettingDescriptor,
+  writeNestedSettingValue
+} from "./chunk-B4O5S7I3.js";
+import {
+  normalizeParentReferencePolicy,
+  normalizeSprintReleaseFormatPolicy
+} from "./chunk-EUKTMRN3.js";
+import {
+  migrateItemFilesToFormat
+} from "./chunk-S62UANU7.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-3LCUASYG.js";
+import "./chunk-IEEJQCZ4.js";
+import "./chunk-AIAIXG7I.js";
+import {
+  CONTEXT_DEPTH_VALUES,
+  EXIT_CODE,
+  PmCliError,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  pathExists,
+  readSettingsWithMetadata,
+  resolveGlobalPmRoot,
+  resolveItemTypeRegistry,
+  resolveItemTypesFilePath,
+  resolvePmRoot,
+  resolveTypeName,
+  writeSettings
+} from "./chunk-7NSPKJUS.js";
+
+// dist/core/config/positional-value.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] = "c7e38647-27e9-5ea0-8c7f-7decefb9a882");
+  } catch (e2) {
+  }
+})();
+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
+!(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] = "a420e612-3d4b-5ebd-864e-a1a4bec5e45d");
+  } catch (e2) {
+  }
+})();
+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, global2) {
+  const cwd = process.cwd();
+  const pmRoot = scope === "project" ? resolvePmRoot(cwd, global2.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, global2, 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, global2);
+  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-G74GISC4.js.map