@unbrained/pm-cli 2026.5.31 → 2026.6.5

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

@@ -0,0 +1,1671 @@
+
+!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]="16a22327-ab5b-5ab9-a4ac-aa5984fb0050")}catch(e){}}();
+import {
+  normalizeParentReferencePolicy,
+  normalizeSprintReleaseFormatPolicy
+} from "./chunk-MISYRLEP.js";
+import {
+  migrateItemFilesToFormat
+} from "./chunk-UFCG3SWR.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-26KTVXJW.js";
+import "./chunk-KBG47ZOY.js";
+import {
+  resolveItemTypeRegistry,
+  resolveTypeName
+} from "./chunk-SZQCER6S.js";
+import "./chunk-NQP3ECKF.js";
+import {
+  CONTEXT_DEPTH_VALUES,
+  EXIT_CODE,
+  PmCliError,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  pathExists,
+  readSettingsWithMetadata,
+  resolveGlobalPmRoot,
+  resolvePmRoot,
+  writeSettings
+} from "./chunk-4LTBNUYT.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_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_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/core/config/nested-settings.js
+var NESTED_SETTING_DESCRIPTORS = [
+  {
+    key: "search_provider",
+    path: "search.provider",
+    kind: "string",
+    summary: "Search embedding provider name (e.g. openai, ollama, or an extension provider)."
+  },
+  {
+    key: "search_mutation_refresh_policy",
+    path: "search.mutation_refresh_policy",
+    kind: "string",
+    choices: ["cache_only", "semantic_configured", "semantic_auto"],
+    summary: "Mutation-time search refresh policy: cache_only, semantic_configured, or semantic_auto."
+  },
+  {
+    key: "search_embedding_model",
+    path: "search.embedding_model",
+    kind: "string",
+    summary: "Default embedding model name (overrides provider-specific model when set)."
+  },
+  {
+    key: "search_embedding_batch_size",
+    path: "search.embedding_batch_size",
+    kind: "integer",
+    min: 1,
+    summary: "Number of items embedded per request batch."
+  },
+  {
+    key: "search_embedding_timeout_ms",
+    path: "search.embedding_timeout_ms",
+    kind: "integer",
+    min: 1,
+    summary: "Per-request embedding timeout in milliseconds."
+  },
+  {
+    key: "search_score_threshold",
+    path: "search.score_threshold",
+    kind: "number",
+    summary: "Minimum score for a hit to be returned (0 keeps all matches)."
+  },
+  {
+    key: "search_hybrid_semantic_weight",
+    path: "search.hybrid_semantic_weight",
+    kind: "ratio",
+    summary: "Hybrid mode semantic weight in [0, 1] (1-weight goes to keyword)."
+  },
+  {
+    key: "search_max_results",
+    path: "search.max_results",
+    kind: "integer",
+    min: 1,
+    summary: "Default upper bound on search hits when --limit is not supplied."
+  },
+  {
+    key: "openai_base_url",
+    path: "providers.openai.base_url",
+    kind: "string",
+    summary: "OpenAI-compatible API base URL (LM Studio/vLLM also use this)."
+  },
+  {
+    key: "openai_api_key",
+    path: "providers.openai.api_key",
+    kind: "string",
+    summary: "OpenAI-compatible API key."
+  },
+  {
+    key: "openai_model",
+    path: "providers.openai.model",
+    kind: "string",
+    summary: "OpenAI-compatible embedding model name."
+  },
+  {
+    key: "ollama_base_url",
+    path: "providers.ollama.base_url",
+    kind: "string",
+    summary: "Ollama API base URL (typically http://localhost:11434)."
+  },
+  {
+    key: "ollama_model",
+    path: "providers.ollama.model",
+    kind: "string",
+    summary: "Ollama embedding model name (e.g. nomic-embed-text)."
+  },
+  {
+    key: "vector_store_adapter",
+    path: "vector_store.adapter",
+    kind: "string",
+    summary: "Vector store adapter name (lancedb, qdrant, or an extension adapter)."
+  },
+  {
+    key: "qdrant_url",
+    path: "vector_store.qdrant.url",
+    kind: "string",
+    summary: "Qdrant HTTP API URL."
+  },
+  {
+    key: "qdrant_api_key",
+    path: "vector_store.qdrant.api_key",
+    kind: "string",
+    summary: "Qdrant API key (empty if running unauthenticated)."
+  },
+  {
+    key: "lancedb_path",
+    path: "vector_store.lancedb.path",
+    kind: "string",
+    summary: "LanceDB storage path (relative to pm root or absolute)."
+  }
+];
+var DESCRIPTOR_BY_KEY = new Map(NESTED_SETTING_DESCRIPTORS.map((descriptor) => [descriptor.key, descriptor]));
+var NESTED_SETTING_KEYS = NESTED_SETTING_DESCRIPTORS.map((descriptor) => descriptor.key);
+function resolveNestedSettingDescriptor(raw) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase().replaceAll("-", "_");
+  if (normalized.length === 0) {
+    return void 0;
+  }
+  return DESCRIPTOR_BY_KEY.get(normalized);
+}
+function parseNestedSettingValue(descriptor, rawValue) {
+  if (typeof rawValue !== "string") {
+    return { ok: false, error: { message: `Config set ${descriptor.key} requires a string value` } };
+  }
+  const trimmed = rawValue.trim();
+  if (descriptor.kind === "string") {
+    if (descriptor.choices && !descriptor.choices.includes(trimmed)) {
+      return {
+        ok: false,
+        error: {
+          message: `Config set ${descriptor.key} must be one of ${descriptor.choices.join("|")}, got "${rawValue}"`
+        }
+      };
+    }
+    return { ok: true, parsed: { descriptor, value: trimmed } };
+  }
+  if (trimmed.length === 0) {
+    return {
+      ok: false,
+      error: { message: `Config set ${descriptor.key} requires a non-empty value` }
+    };
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed)) {
+    return {
+      ok: false,
+      error: { message: `Config set ${descriptor.key} requires a finite number, got "${rawValue}"` }
+    };
+  }
+  if (descriptor.kind === "integer") {
+    if (!Number.isInteger(parsed) || parsed < 0) {
+      return {
+        ok: false,
+        error: { message: `Config set ${descriptor.key} requires a non-negative integer, got "${rawValue}"` }
+      };
+    }
+    if (descriptor.min !== void 0 && parsed < descriptor.min) {
+      return {
+        ok: false,
+        error: {
+          message: `Config set ${descriptor.key} requires an integer >= ${descriptor.min}, got "${rawValue}" (the runtime silently ignores 0 here and falls back to the default)`
+        }
+      };
+    }
+    return { ok: true, parsed: { descriptor, value: parsed } };
+  }
+  if (descriptor.kind === "ratio") {
+    if (parsed < 0 || parsed > 1) {
+      return {
+        ok: false,
+        error: { message: `Config set ${descriptor.key} requires a number in [0, 1], got "${rawValue}"` }
+      };
+    }
+    return { ok: true, parsed: { descriptor, value: parsed } };
+  }
+  if (descriptor.min !== void 0 && parsed < descriptor.min) {
+    return {
+      ok: false,
+      error: { message: `Config set ${descriptor.key} requires a number >= ${descriptor.min}, got "${rawValue}"` }
+    };
+  }
+  return { ok: true, parsed: { descriptor, value: parsed } };
+}
+function readNestedSettingValue(settings, descriptor) {
+  const segments = descriptor.path.split(".");
+  let cursor = settings;
+  for (const segment of segments) {
+    if (typeof cursor !== "object" || cursor === null) {
+      return null;
+    }
+    cursor = cursor[segment];
+  }
+  if (typeof cursor === "string" || typeof cursor === "number") {
+    return cursor;
+  }
+  return null;
+}
+function writeNestedSettingValue(settings, descriptor, value) {
+  const segments = descriptor.path.split(".");
+  let cursor = settings;
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    const segment = segments[index];
+    const existing = cursor[segment];
+    if (typeof existing !== "object" || existing === null || Array.isArray(existing)) {
+      const next = {};
+      cursor[segment] = next;
+      cursor = next;
+    } else {
+      cursor = existing;
+    }
+  }
+  const leafKey = segments[segments.length - 1];
+  const previous = cursor[leafKey];
+  if (previous === value) {
+    return false;
+  }
+  cursor[leafKey] = value;
+  return true;
+}
+
+// dist/cli/commands/config.js
+var CONFIG_SCOPE_VALUES = ["project", "global"];
+var CONFIG_KEY_VALUES = [
+  "definition-of-done",
+  "definition_of_done",
+  "item-format",
+  "item_format",
+  "history-missing-stream-policy",
+  "history_missing_stream_policy",
+  "sprint-release-format-policy",
+  "sprint_release_format_policy",
+  "parent-reference-policy",
+  "parent_reference_policy",
+  "metadata-validation-profile",
+  "metadata_validation_profile",
+  "metadata-required-fields",
+  "metadata_required_fields",
+  "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-resolution-patterns",
+  "lifecycle_closure_like_resolution_patterns",
+  "lifecycle-closure-like-actual-result-patterns",
+  "lifecycle_closure_like_actual_result_patterns",
+  "governance-preset",
+  "governance_preset",
+  "governance-ownership-enforcement",
+  "governance_ownership_enforcement",
+  "governance-create-mode-default",
+  "governance_create_mode_default",
+  "governance-close-validation-default",
+  "governance_close_validation_default",
+  "governance-create-default-type",
+  "governance_create_default_type",
+  "governance-workflow-enforcement",
+  "governance_workflow_enforcement",
+  "governance-parent-reference-policy",
+  "governance_parent_reference_policy",
+  "governance-metadata-validation-profile",
+  "governance_metadata_validation_profile",
+  "governance-force-required-for-stale-lock",
+  "governance_force_required_for_stale_lock",
+  "test-result-tracking",
+  "test_result_tracking",
+  "telemetry-tracking",
+  "telemetry_tracking",
+  "context"
+];
+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_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_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_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"
+];
+function isCriteriaConfigKey(key) {
+  return key === "definition_of_done" || key === "metadata_required_fields" || LIFECYCLE_PATTERN_CONFIG_KEYS.includes(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) {
+  if (CONFIG_KEY_VALUES.includes(value)) {
+    if (value === "item-format" || value === "item_format") {
+      return "item_format";
+    }
+    if (value === "history-missing-stream-policy" || value === "history_missing_stream_policy") {
+      return "history_missing_stream_policy";
+    }
+    if (value === "sprint-release-format-policy" || value === "sprint_release_format_policy") {
+      return "sprint_release_format_policy";
+    }
+    if (value === "parent-reference-policy" || value === "parent_reference_policy") {
+      return "parent_reference_policy";
+    }
+    if (value === "metadata-validation-profile" || value === "metadata_validation_profile") {
+      return "metadata_validation_profile";
+    }
+    if (value === "metadata-required-fields" || value === "metadata_required_fields") {
+      return "metadata_required_fields";
+    }
+    if (value === "lifecycle-stale-blocker-reason-patterns" || value === "lifecycle_stale_blocker_reason_patterns") {
+      return "lifecycle_stale_blocker_reason_patterns";
+    }
+    if (value === "lifecycle-closure-like-blocked-reason-patterns" || value === "lifecycle_closure_like_blocked_reason_patterns") {
+      return "lifecycle_closure_like_blocked_reason_patterns";
+    }
+    if (value === "lifecycle-closure-like-resolution-patterns" || value === "lifecycle_closure_like_resolution_patterns") {
+      return "lifecycle_closure_like_resolution_patterns";
+    }
+    if (value === "lifecycle-closure-like-actual-result-patterns" || value === "lifecycle_closure_like_actual_result_patterns") {
+      return "lifecycle_closure_like_actual_result_patterns";
+    }
+    if (value === "governance-preset" || value === "governance_preset") {
+      return "governance_preset";
+    }
+    if (value === "governance-ownership-enforcement" || value === "governance_ownership_enforcement") {
+      return "governance_ownership_enforcement";
+    }
+    if (value === "governance-create-mode-default" || value === "governance_create_mode_default") {
+      return "governance_create_mode_default";
+    }
+    if (value === "governance-close-validation-default" || value === "governance_close_validation_default") {
+      return "governance_close_validation_default";
+    }
+    if (value === "governance-create-default-type" || value === "governance_create_default_type") {
+      return "governance_create_default_type";
+    }
+    if (value === "governance-workflow-enforcement" || value === "governance_workflow_enforcement") {
+      return "governance_workflow_enforcement";
+    }
+    if (value === "governance-parent-reference-policy" || value === "governance_parent_reference_policy") {
+      return "governance_parent_reference_policy";
+    }
+    if (value === "governance-metadata-validation-profile" || value === "governance_metadata_validation_profile") {
+      return "governance_metadata_validation_profile";
+    }
+    if (value === "governance-force-required-for-stale-lock" || value === "governance_force_required_for_stale_lock") {
+      return "governance_force_required_for_stale_lock";
+    }
+    if (value === "test-result-tracking" || value === "test_result_tracking") {
+      return "test_result_tracking";
+    }
+    if (value === "telemetry-tracking" || value === "telemetry_tracking") {
+      return "telemetry_tracking";
+    }
+    if (value === "context") {
+      return "context";
+    }
+    return "definition_of_done";
+  }
+  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 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_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 readConfigValue(settings, key) {
+  if (key === "item_format") {
+    return settings.item_format;
+  }
+  if (key === "history_missing_stream_policy") {
+    return settings.history.missing_stream;
+  }
+  if (key === "sprint_release_format_policy") {
+    return settings.validation.sprint_release_format;
+  }
+  if (key === "parent_reference_policy") {
+    return settings.validation.parent_reference;
+  }
+  if (key === "metadata_validation_profile") {
+    return settings.validation.metadata_profile;
+  }
+  if (key === "metadata_required_fields") {
+    return [...settings.validation.metadata_required_fields];
+  }
+  if (key === "lifecycle_stale_blocker_reason_patterns") {
+    return [...settings.validation.lifecycle_stale_blocker_reason_patterns];
+  }
+  if (key === "lifecycle_closure_like_blocked_reason_patterns") {
+    return [...settings.validation.lifecycle_closure_like_blocked_reason_patterns];
+  }
+  if (key === "lifecycle_closure_like_resolution_patterns") {
+    return [...settings.validation.lifecycle_closure_like_resolution_patterns];
+  }
+  if (key === "lifecycle_closure_like_actual_result_patterns") {
+    return [...settings.validation.lifecycle_closure_like_actual_result_patterns];
+  }
+  if (key === "governance_preset") {
+    return settings.governance.preset;
+  }
+  if (key === "governance_ownership_enforcement") {
+    return settings.governance.ownership_enforcement;
+  }
+  if (key === "governance_create_mode_default") {
+    return settings.governance.create_mode_default;
+  }
+  if (key === "governance_close_validation_default") {
+    return settings.governance.close_validation_default;
+  }
+  if (key === "governance_create_default_type") {
+    return settings.governance.create_default_type ?? "";
+  }
+  if (key === "governance_workflow_enforcement") {
+    return settings.governance.workflow_enforcement ?? "off";
+  }
+  if (key === "governance_parent_reference_policy") {
+    return settings.governance.parent_reference;
+  }
+  if (key === "governance_metadata_validation_profile") {
+    return settings.governance.metadata_profile;
+  }
+  if (key === "governance_force_required_for_stale_lock") {
+    return settings.governance.force_required_for_stale_lock ? "enabled" : "disabled";
+  }
+  if (key === "test_result_tracking") {
+    return settings.testing.record_results_to_items ? "enabled" : "disabled";
+  }
+  if (key === "telemetry_tracking") {
+    return settings.telemetry.enabled ? "enabled" : "disabled";
+  }
+  if (key === "context") {
+    return {
+      default_depth: settings.context.default_depth,
+      activity_limit: settings.context.activity_limit,
+      stale_threshold_days: settings.context.stale_threshold_days,
+      sections: { ...settings.context.sections }
+    };
+  }
+  return [...settings.workflow.definition_of_done];
+}
+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 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) {
+    if (options.value !== void 0 && valueValue !== 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 ?? options.value };
+  }
+  const routed = resolveConfigPositionalValue(normalizedKey ?? keyValue, 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 };
+}
+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);
+  options = applyPositionalValue(action, keyValue, key, nestedSetting, valueValue, options);
+  const target = await resolveSettingsTarget(scope, global);
+  const { settings, metadata, warnings: settingsReadWarnings } = await readSettingsWithMetadata(target.pmRoot);
+  const warnings = normalizeWarnings(settingsReadWarnings);
+  if (nestedSetting) {
+    if (action === "get") {
+      const currentValue = readNestedSettingValue(settings, nestedSetting);
+      return withWarnings({
+        scope,
+        key: nestedSetting.key,
+        nested_setting: {
+          key: nestedSetting.key,
+          path: nestedSetting.path,
+          kind: nestedSetting.kind,
+          value: currentValue
+        },
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    const rawValue = options.value;
+    if (typeof rawValue !== "string") {
+      throw new PmCliError(`Config set ${nestedSetting.key} requires a value. Pass it positionally (\`pm config ${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 changed2 = writeNestedSettingValue(settings, nestedSetting, parsed.parsed.value);
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, `config:set:${nestedSetting.path}`);
+    }
+    return withWarnings({
+      scope,
+      key: nestedSetting.key,
+      nested_setting: {
+        key: nestedSetting.key,
+        path: nestedSetting.path,
+        kind: nestedSetting.kind,
+        value: parsed.parsed.value
+      },
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (action === "list") {
+    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(settings, candidate)
+    }));
+    const nestedSettings = NESTED_SETTING_DESCRIPTORS.map((descriptor) => ({
+      key: descriptor.key,
+      path: descriptor.path,
+      kind: descriptor.kind,
+      value: readNestedSettingValue(settings, descriptor)
+    }));
+    return withWarnings({
+      scope,
+      keys,
+      nested_settings: nestedSettings,
+      count: keys.length,
+      settings_path: target.settingsPath,
+      changed: false
+    }, warnings);
+  }
+  if (action === "export") {
+    const values = {
+      definition_of_done: readConfigValue(settings, "definition_of_done"),
+      item_format: readConfigValue(settings, "item_format"),
+      history_missing_stream_policy: readConfigValue(settings, "history_missing_stream_policy"),
+      sprint_release_format_policy: readConfigValue(settings, "sprint_release_format_policy"),
+      parent_reference_policy: readConfigValue(settings, "parent_reference_policy"),
+      metadata_validation_profile: readConfigValue(settings, "metadata_validation_profile"),
+      metadata_required_fields: readConfigValue(settings, "metadata_required_fields"),
+      lifecycle_stale_blocker_reason_patterns: readConfigValue(settings, "lifecycle_stale_blocker_reason_patterns"),
+      lifecycle_closure_like_blocked_reason_patterns: readConfigValue(settings, "lifecycle_closure_like_blocked_reason_patterns"),
+      lifecycle_closure_like_resolution_patterns: readConfigValue(settings, "lifecycle_closure_like_resolution_patterns"),
+      lifecycle_closure_like_actual_result_patterns: readConfigValue(settings, "lifecycle_closure_like_actual_result_patterns"),
+      governance_preset: readConfigValue(settings, "governance_preset"),
+      governance_ownership_enforcement: readConfigValue(settings, "governance_ownership_enforcement"),
+      governance_create_mode_default: readConfigValue(settings, "governance_create_mode_default"),
+      governance_close_validation_default: readConfigValue(settings, "governance_close_validation_default"),
+      governance_create_default_type: readConfigValue(settings, "governance_create_default_type"),
+      governance_workflow_enforcement: readConfigValue(settings, "governance_workflow_enforcement"),
+      governance_parent_reference_policy: readConfigValue(settings, "governance_parent_reference_policy"),
+      governance_metadata_validation_profile: readConfigValue(settings, "governance_metadata_validation_profile"),
+      governance_force_required_for_stale_lock: readConfigValue(settings, "governance_force_required_for_stale_lock"),
+      test_result_tracking: readConfigValue(settings, "test_result_tracking"),
+      telemetry_tracking: readConfigValue(settings, "telemetry_tracking"),
+      context: readConfigValue(settings, "context")
+    };
+    return withWarnings({
+      scope,
+      values,
+      settings_path: target.settingsPath,
+      changed: false
+    }, warnings);
+  }
+  if (action === "get") {
+    if (!key) {
+      throw new PmCliError('Config action "get" requires <key>', EXIT_CODE.USAGE);
+    }
+    if (key === "item_format") {
+      return withWarnings({
+        scope,
+        key,
+        format: settings.item_format,
+        has_explicit_item_format: metadata.has_explicit_item_format,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "history_missing_stream_policy") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.history.missing_stream,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "sprint_release_format_policy") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.validation.sprint_release_format,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "parent_reference_policy") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.validation.parent_reference,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "metadata_validation_profile") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.validation.metadata_profile,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "metadata_required_fields") {
+      return withWarnings({
+        scope,
+        key,
+        criteria: [...settings.validation.metadata_required_fields],
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "lifecycle_stale_blocker_reason_patterns") {
+      return withWarnings({
+        scope,
+        key,
+        criteria: [...settings.validation.lifecycle_stale_blocker_reason_patterns],
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "lifecycle_closure_like_blocked_reason_patterns") {
+      return withWarnings({
+        scope,
+        key,
+        criteria: [...settings.validation.lifecycle_closure_like_blocked_reason_patterns],
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "lifecycle_closure_like_resolution_patterns") {
+      return withWarnings({
+        scope,
+        key,
+        criteria: [...settings.validation.lifecycle_closure_like_resolution_patterns],
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "lifecycle_closure_like_actual_result_patterns") {
+      return withWarnings({
+        scope,
+        key,
+        criteria: [...settings.validation.lifecycle_closure_like_actual_result_patterns],
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_preset") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.preset,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_ownership_enforcement") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.ownership_enforcement,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_create_mode_default") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.create_mode_default,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_close_validation_default") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.close_validation_default,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_create_default_type") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.create_default_type ?? "",
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_workflow_enforcement") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.workflow_enforcement ?? "off",
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_parent_reference_policy") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.parent_reference,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_metadata_validation_profile") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.metadata_profile,
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "governance_force_required_for_stale_lock") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.force_required_for_stale_lock ? "enabled" : "disabled",
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "test_result_tracking") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.testing.record_results_to_items ? "enabled" : "disabled",
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "telemetry_tracking") {
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.telemetry.enabled ? "enabled" : "disabled",
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    if (key === "context") {
+      return withWarnings({
+        scope,
+        key,
+        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 }
+        },
+        settings_path: target.settingsPath,
+        changed: false
+      }, warnings);
+    }
+    return withWarnings({
+      scope,
+      key,
+      criteria: [...settings.workflow.definition_of_done],
+      settings_path: target.settingsPath,
+      changed: false
+    }, warnings);
+  }
+  if (!key) {
+    throw new PmCliError('Config action "set" requires <key>', EXIT_CODE.USAGE);
+  }
+  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") {
+    const nextFormat = normalizeItemFormat(options.format);
+    const changed2 = settings.item_format !== nextFormat || !metadata.has_explicit_item_format;
+    let migration = void 0;
+    if (changed2) {
+      const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+      const migrated = await migrateItemFilesToFormat(target.pmRoot, nextFormat, "config:set:item_format:migrate", typeRegistry.type_to_folder, settings.schema);
+      migration = {
+        target_format: migrated.target_format,
+        scanned: migrated.scanned,
+        migrated: migrated.migrated,
+        removed: migrated.removed,
+        warnings: migrated.warnings
+      };
+      settings.item_format = nextFormat;
+      await writeSettings(target.pmRoot, settings, "config:set:item_format");
+    }
+    return withWarnings({
+      scope,
+      key,
+      format: settings.item_format,
+      has_explicit_item_format: true,
+      migration,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "history_missing_stream_policy") {
+    const nextPolicy = normalizeHistoryMissingStreamPolicy(options.policy);
+    const changed2 = settings.history.missing_stream !== nextPolicy;
+    settings.history.missing_stream = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:history_missing_stream_policy");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.history.missing_stream,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "sprint_release_format_policy") {
+    const nextPolicy = normalizeSprintReleaseFormatPolicy(options.policy);
+    const changed2 = settings.validation.sprint_release_format !== nextPolicy;
+    settings.validation.sprint_release_format = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:sprint_release_format_policy");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.validation.sprint_release_format,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "parent_reference_policy") {
+    const nextPolicy = normalizeParentReferencePolicy(options.policy);
+    const changed2 = settings.validation.parent_reference !== nextPolicy || settings.governance.preset !== "custom" || settings.governance.parent_reference !== nextPolicy;
+    settings.validation.parent_reference = nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.parent_reference = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:parent_reference_policy");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.validation.parent_reference,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "metadata_validation_profile") {
+    const nextPolicy = normalizeValidateMetadataProfile(options.policy);
+    const changed2 = settings.validation.metadata_profile !== nextPolicy || settings.governance.preset !== "custom" || settings.governance.metadata_profile !== nextPolicy;
+    settings.validation.metadata_profile = nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.metadata_profile = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:metadata_validation_profile");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.validation.metadata_profile,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "metadata_required_fields") {
+    const nextCriteria2 = normalizeMetadataRequiredFields(options.criterion, options.clearCriteria);
+    const changed2 = nextCriteria2.length !== settings.validation.metadata_required_fields.length || nextCriteria2.some((value, index) => value !== settings.validation.metadata_required_fields[index]);
+    settings.validation.metadata_required_fields = nextCriteria2;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:metadata_required_fields");
+    }
+    return withWarnings({
+      scope,
+      key,
+      criteria: [...settings.validation.metadata_required_fields],
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "lifecycle_stale_blocker_reason_patterns") {
+    const nextCriteria2 = normalizeLifecyclePatternCriteria(key, options.criterion, options.clearCriteria);
+    const changed2 = nextCriteria2.length !== settings.validation.lifecycle_stale_blocker_reason_patterns.length || nextCriteria2.some((value, index) => value !== settings.validation.lifecycle_stale_blocker_reason_patterns[index]);
+    settings.validation.lifecycle_stale_blocker_reason_patterns = nextCriteria2;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:lifecycle_stale_blocker_reason_patterns");
+    }
+    return withWarnings({
+      scope,
+      key,
+      criteria: [...settings.validation.lifecycle_stale_blocker_reason_patterns],
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "lifecycle_closure_like_blocked_reason_patterns") {
+    const nextCriteria2 = normalizeLifecyclePatternCriteria(key, options.criterion, options.clearCriteria);
+    const changed2 = nextCriteria2.length !== settings.validation.lifecycle_closure_like_blocked_reason_patterns.length || nextCriteria2.some((value, index) => value !== settings.validation.lifecycle_closure_like_blocked_reason_patterns[index]);
+    settings.validation.lifecycle_closure_like_blocked_reason_patterns = nextCriteria2;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:lifecycle_closure_like_blocked_reason_patterns");
+    }
+    return withWarnings({
+      scope,
+      key,
+      criteria: [...settings.validation.lifecycle_closure_like_blocked_reason_patterns],
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "lifecycle_closure_like_resolution_patterns") {
+    const nextCriteria2 = normalizeLifecyclePatternCriteria(key, options.criterion, options.clearCriteria);
+    const changed2 = nextCriteria2.length !== settings.validation.lifecycle_closure_like_resolution_patterns.length || nextCriteria2.some((value, index) => value !== settings.validation.lifecycle_closure_like_resolution_patterns[index]);
+    settings.validation.lifecycle_closure_like_resolution_patterns = nextCriteria2;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:lifecycle_closure_like_resolution_patterns");
+    }
+    return withWarnings({
+      scope,
+      key,
+      criteria: [...settings.validation.lifecycle_closure_like_resolution_patterns],
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "lifecycle_closure_like_actual_result_patterns") {
+    const nextCriteria2 = normalizeLifecyclePatternCriteria(key, options.criterion, options.clearCriteria);
+    const changed2 = nextCriteria2.length !== settings.validation.lifecycle_closure_like_actual_result_patterns.length || nextCriteria2.some((value, index) => value !== settings.validation.lifecycle_closure_like_actual_result_patterns[index]);
+    settings.validation.lifecycle_closure_like_actual_result_patterns = nextCriteria2;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:lifecycle_closure_like_actual_result_patterns");
+    }
+    return withWarnings({
+      scope,
+      key,
+      criteria: [...settings.validation.lifecycle_closure_like_actual_result_patterns],
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_preset") {
+    const nextPolicy = normalizeGovernancePreset(options.policy);
+    const changed2 = settings.governance.preset !== nextPolicy;
+    settings.governance.preset = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_preset");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.preset,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_ownership_enforcement") {
+    const nextPolicy = normalizeGovernanceOwnershipEnforcement(options.policy);
+    const changed2 = settings.governance.preset !== "custom" || settings.governance.ownership_enforcement !== nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.ownership_enforcement = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_ownership_enforcement");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.ownership_enforcement,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_create_mode_default") {
+    const nextPolicy = normalizeGovernanceCreateModeDefault(options.policy);
+    const changed2 = settings.governance.preset !== "custom" || settings.governance.create_mode_default !== nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.create_mode_default = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_create_mode_default");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.create_mode_default,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_close_validation_default") {
+    const nextPolicy = normalizeGovernanceCloseValidationDefault(options.policy);
+    const changed2 = settings.governance.preset !== "custom" || settings.governance.close_validation_default !== nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.close_validation_default = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_close_validation_default");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.close_validation_default,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_create_default_type") {
+    const policyProvided = typeof options.policy === "string";
+    const rawType = policyProvided ? options.policy.trim() : "";
+    if (policyProvided && rawType.length === 0) {
+      const changed3 = settings.governance.create_default_type !== void 0;
+      delete settings.governance.create_default_type;
+      if (changed3) {
+        await writeSettings(target.pmRoot, settings, "config:set:governance_create_default_type");
+      }
+      return withWarnings({
+        scope,
+        key,
+        policy: settings.governance.create_default_type ?? "",
+        settings_path: target.settingsPath,
+        changed: changed3
+      }, warnings);
+    }
+    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(settings, getActiveExtensionRegistrations());
+    const resolvedType = resolveTypeName(rawType, typeRegistry);
+    if (!resolvedType) {
+      throw new PmCliError(buildInvalidTypeError(rawType, typeRegistry.types), EXIT_CODE.USAGE);
+    }
+    const changed2 = settings.governance.create_default_type !== resolvedType;
+    settings.governance.create_default_type = resolvedType;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_create_default_type");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.create_default_type,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_workflow_enforcement") {
+    const nextPolicy = normalizeGovernanceWorkflowEnforcement(options.policy);
+    const changed2 = (settings.governance.workflow_enforcement ?? "off") !== nextPolicy;
+    settings.governance.workflow_enforcement = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_workflow_enforcement");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.workflow_enforcement,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_parent_reference_policy") {
+    const nextPolicy = normalizeParentReferencePolicy(options.policy);
+    const changed2 = settings.governance.preset !== "custom" || settings.governance.parent_reference !== nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.parent_reference = nextPolicy;
+    settings.validation.parent_reference = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_parent_reference_policy");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.parent_reference,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_metadata_validation_profile") {
+    const nextPolicy = normalizeValidateMetadataProfile(options.policy);
+    const changed2 = settings.governance.preset !== "custom" || settings.governance.metadata_profile !== nextPolicy;
+    settings.governance.preset = "custom";
+    settings.governance.metadata_profile = nextPolicy;
+    settings.validation.metadata_profile = nextPolicy;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_metadata_validation_profile");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.metadata_profile,
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "governance_force_required_for_stale_lock") {
+    const nextPolicy = normalizeGovernanceForceRequiredForStaleLockPolicy(options.policy);
+    const nextEnabled = nextPolicy === "enabled";
+    const changed2 = settings.governance.preset !== "custom" || settings.governance.force_required_for_stale_lock !== nextEnabled;
+    settings.governance.preset = "custom";
+    settings.governance.force_required_for_stale_lock = nextEnabled;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:governance_force_required_for_stale_lock");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.governance.force_required_for_stale_lock ? "enabled" : "disabled",
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "test_result_tracking") {
+    const nextPolicy = normalizeTestResultTrackingPolicy(options.policy);
+    const nextEnabled = nextPolicy === "enabled";
+    const changed2 = settings.testing.record_results_to_items !== nextEnabled;
+    settings.testing.record_results_to_items = nextEnabled;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:test_result_tracking");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.testing.record_results_to_items ? "enabled" : "disabled",
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "telemetry_tracking") {
+    const nextPolicy = normalizeTelemetryTrackingPolicy(options.policy);
+    const nextEnabled = nextPolicy === "enabled";
+    const changed2 = settings.telemetry.enabled !== nextEnabled || !settings.telemetry.first_run_prompt_completed;
+    settings.telemetry.enabled = nextEnabled;
+    settings.telemetry.first_run_prompt_completed = true;
+    if (changed2) {
+      await writeSettings(target.pmRoot, settings, "config:set:telemetry_tracking");
+    }
+    return withWarnings({
+      scope,
+      key,
+      policy: settings.telemetry.enabled ? "enabled" : "disabled",
+      settings_path: target.settingsPath,
+      changed: changed2
+    }, warnings);
+  }
+  if (key === "context") {
+    return applyContextConfig(settings, options, target, scope, warnings);
+  }
+  const nextCriteria = normalizeCriteria(options.criterion, options.clearCriteria);
+  const changed = nextCriteria.length !== settings.workflow.definition_of_done.length || nextCriteria.some((value, index) => value !== settings.workflow.definition_of_done[index]);
+  settings.workflow.definition_of_done = nextCriteria;
+  if (changed) {
+    await writeSettings(target.pmRoot, settings, "config:set:definition_of_done");
+  }
+  return withWarnings({
+    scope,
+    key,
+    criteria: [...settings.workflow.definition_of_done],
+    settings_path: target.settingsPath,
+    changed
+  }, warnings);
+}
+export {
+  runConfig
+};
+//# sourceMappingURL=config-DDPYIA6J.js.map
+
+//# debugId=16a22327-ab5b-5ab9-a4ac-aa5984fb0050