@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-UI5BJ6DO.js

@@ -1,4786 +0,0 @@
-import {
-  KNOWN_EXTENSION_CAPABILITIES,
-  KNOWN_EXTENSION_POLICY_MODES,
-  KNOWN_EXTENSION_POLICY_SURFACES,
-  KNOWN_EXTENSION_SANDBOX_PROFILES,
-  KNOWN_EXTENSION_SERVICE_NAMES,
-  KNOWN_EXTENSION_TRUST_MODES,
-  PLAN_HARNESS_VALUES,
-  PLAN_MODE_VALUES,
-  PLAN_STEP_LINK_KIND_VALUES,
-  PLAN_STEP_STATUS_VALUES
-} from "./chunk-5VVUKE3U.js";
-
-// dist/sdk/cli-contracts/commander-types.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] = "240b5f92-6ceb-5cf9-8739-9e921df6c27b");
-  } catch (e2) {
-  }
-})();
-var LIST_COMMANDER_STRING_OPTION_CONTRACTS = [
-  { target: "status", keys: ["status"] },
-  { target: "type", keys: ["type"] },
-  { target: "tag", keys: ["tag", "tags"] },
-  { target: "priority", keys: ["priority"] },
-  { target: "deadlineBefore", keys: ["deadlineBefore"] },
-  { target: "deadlineAfter", keys: ["deadlineAfter"] },
-  { target: "updatedAfter", keys: ["updatedAfter"] },
-  { target: "updatedBefore", keys: ["updatedBefore"] },
-  { target: "createdAfter", keys: ["createdAfter"] },
-  { target: "createdBefore", keys: ["createdBefore"] },
-  { target: "ids", keys: ["ids"] },
-  { target: "assignee", keys: ["assignee"] },
-  { target: "assigneeFilter", keys: ["assigneeFilter", "assignee_filter"] },
-  { target: "parent", keys: ["parent"] },
-  { target: "sprint", keys: ["sprint"] },
-  { target: "release", keys: ["release"] },
-  { target: "limit", keys: ["limit"] },
-  { target: "offset", keys: ["offset"] },
-  { target: "fields", keys: ["fields"] },
-  { target: "sort", keys: ["sort"] },
-  { target: "order", keys: ["order"] },
-  { target: "treeDepth", keys: ["treeDepth", "tree_depth"] }
-];
-var SEARCH_COMMANDER_STRING_OPTION_CONTRACTS = [
-  { target: "mode", keys: ["mode"] },
-  { target: "matchMode", keys: ["matchMode", "match_mode"] },
-  { target: "minScore", keys: ["minScore", "min_score"] },
-  { target: "semanticWeight", keys: ["semanticWeight", "semantic_weight"] },
-  { target: "status", keys: ["status"] },
-  { target: "type", keys: ["type"] },
-  { target: "tag", keys: ["tag", "tags"] },
-  { target: "priority", keys: ["priority"] },
-  { target: "deadlineBefore", keys: ["deadlineBefore"] },
-  { target: "deadlineAfter", keys: ["deadlineAfter"] },
-  { target: "updatedAfter", keys: ["updatedAfter"] },
-  { target: "updatedBefore", keys: ["updatedBefore"] },
-  { target: "createdAfter", keys: ["createdAfter"] },
-  { target: "createdBefore", keys: ["createdBefore"] },
-  { target: "assignee", keys: ["assignee"] },
-  { target: "sprint", keys: ["sprint"] },
-  { target: "release", keys: ["release"] },
-  { target: "parent", keys: ["parent"] },
-  { target: "fields", keys: ["fields"] },
-  { target: "limit", keys: ["limit"] }
-];
-var CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS = [
-  { target: "view", keys: ["view"] },
-  { target: "date", keys: ["date"] },
-  { target: "from", keys: ["from"] },
-  { target: "to", keys: ["to"] },
-  { target: "limit", keys: ["limit"] },
-  { target: "type", keys: ["type"] },
-  { target: "tag", keys: ["tag"] },
-  { target: "priority", keys: ["priority"] },
-  { target: "status", keys: ["status"] },
-  { target: "assignee", keys: ["assignee"] },
-  { target: "assigneeFilter", keys: ["assigneeFilter", "assignee_filter"] },
-  { target: "sprint", keys: ["sprint"] },
-  { target: "release", keys: ["release"] },
-  { target: "include", keys: ["include"] },
-  { target: "recurrenceLookaheadDays", keys: ["recurrenceLookaheadDays", "recurrence_lookahead_days"] },
-  { target: "recurrenceLookbackDays", keys: ["recurrenceLookbackDays", "recurrence_lookback_days"] },
-  { target: "occurrenceLimit", keys: ["occurrenceLimit", "occurrence_limit"] },
-  { target: "format", keys: ["format"] }
-];
-var CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS = [
-  { target: "date", keys: ["date"] },
-  { target: "from", keys: ["from"] },
-  { target: "to", keys: ["to"] },
-  { target: "type", keys: ["type"] },
-  { target: "tag", keys: ["tag"] },
-  { target: "priority", keys: ["priority"] },
-  { target: "assignee", keys: ["assignee"] },
-  { target: "assigneeFilter", keys: ["assigneeFilter", "assignee_filter"] },
-  { target: "sprint", keys: ["sprint"] },
-  { target: "release", keys: ["release"] },
-  { target: "parent", keys: ["parent"] },
-  { target: "limit", keys: ["limit"] },
-  { target: "format", keys: ["format"] },
-  { target: "depth", keys: ["depth"] },
-  { target: "fields", keys: ["fields"] },
-  { target: "activityLimit", keys: ["activityLimit", "activity_limit"] },
-  { target: "staleThreshold", keys: ["staleThreshold", "stale_threshold"] }
-];
-var NEXT_COMMANDER_STRING_OPTION_CONTRACTS = [
-  { target: "type", keys: ["type"] },
-  { target: "tag", keys: ["tag"] },
-  { target: "priority", keys: ["priority"] },
-  { target: "assignee", keys: ["assignee"] },
-  { target: "assigneeFilter", keys: ["assigneeFilter", "assignee_filter"] },
-  { target: "sprint", keys: ["sprint"] },
-  { target: "release", keys: ["release"] },
-  { target: "parent", keys: ["parent"] },
-  { target: "limit", keys: ["limit"] },
-  { target: "blockedLimit", keys: ["blockedLimit", "blocked_limit"] },
-  { target: "format", keys: ["format"] }
-];
-var ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS = [
-  { target: "id", keys: ["id"] },
-  { target: "op", keys: ["op"] },
-  { target: "author", keys: ["author"] },
-  { target: "from", keys: ["from"] },
-  { target: "to", keys: ["to"] },
-  { target: "limit", keys: ["limit"] }
-];
-function readFirstStringFromCommanderOptions(options, contract) {
-  for (const key of contract.keys) {
-    const candidate = options[key];
-    if (typeof candidate === "string") {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-function readFirstValueFromCommanderOptions(options, contract) {
-  for (const key of contract.keys) {
-    if (Object.hasOwn(options, key)) {
-      return options[key];
-    }
-  }
-  return void 0;
-}
-function readStringArrayFromCommanderOptions(options, contract) {
-  for (const key of contract.keys) {
-    const candidate = options[key];
-    if (Array.isArray(candidate)) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-
-// dist/sdk/cli-contracts/commander-mutation-options.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] = "767461eb-c0bf-5d67-83c1-50f5cb1dcfc1");
-  } catch (e2) {
-  }
-})();
-var CREATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS = [
-  {
-    target: "title",
-    keys: ["title"],
-    option: "--title, -t <value>",
-    description: "Item title [required] (or pass title as the first positional argument)"
-  },
-  { target: "id", keys: ["id"], option: "--id <value>", description: "Explicit item id (normalized with the configured id_prefix)" },
-  {
-    target: "description",
-    keys: ["description"],
-    option: "--description, -d <value>",
-    description: "Item description (allow empty string)"
-  },
-  { target: "type", keys: ["type"], option: "--type <value>", description: "Item type (built-ins plus any configured custom types)" },
-  { target: "template", keys: ["template"], option: "--template <value>", description: "Apply named create template defaults before explicit flags" },
-  {
-    target: "createMode",
-    keys: ["createMode", "create_mode"],
-    option: "--create-mode <value>",
-    description: "Create required-option policy mode: strict|progressive",
-    aliasOptions: [{ option: "--create_mode <value>", description: "Alias for --create-mode" }]
-  },
-  {
-    target: "schedulePreset",
-    keys: ["schedulePreset", "schedule_preset"],
-    option: "--schedule-preset <value>",
-    description: "Scheduling preset for Reminder|Meeting|Event: lightweight",
-    aliasOptions: [{ option: "--schedule_preset <value>", description: "Alias for --schedule-preset" }]
-  },
-  { target: "status", keys: ["status"], option: "--status, -s <value>", description: "Item status" },
-  { target: "priority", keys: ["priority"], option: "--priority, -p <value>", description: "Priority 0..4" },
-  { target: "tags", keys: ["tags"], option: "--tags <value>", description: "Comma-separated tags" },
-  {
-    target: "addTags",
-    keys: ["addTags", "add_tags"],
-    option: "--add-tags <value>",
-    description: "Add tags additively on top of --tags (repeatable; CSV accepted)",
-    repeatable: true,
-    aliasOptions: [{ option: "--add_tags <value>", description: "Alias for --add-tags" }]
-  },
-  { target: "body", keys: ["body"], option: "--body, -b <value>", description: "Item markdown body (allow empty string)" },
-  { target: "deadline", keys: ["deadline"], option: "--deadline <value>", description: "Deadline (ISO/date string or relative +6h/+1d/+2w/+6m)" },
-  {
-    target: "estimatedMinutes",
-    keys: ["estimate", "estimatedMinutes", "estimated_minutes"],
-    option: "--estimate, --estimated-minutes <value>",
-    description: "Estimated minutes",
-    aliasOptions: [{ option: "--estimated_minutes <value>", description: "Alias for --estimated-minutes" }]
-  },
-  {
-    target: "acceptanceCriteria",
-    keys: ["acceptanceCriteria", "acceptance_criteria", "ac"],
-    option: "--acceptance-criteria <value>",
-    description: "Acceptance criteria (allow empty string)",
-    aliasOptions: [
-      { option: "--acceptance_criteria <value>", description: "Alias for --acceptance-criteria" },
-      { option: "--ac <value>", description: "Alias for --acceptance-criteria" }
-    ]
-  },
-  {
-    target: "definitionOfReady",
-    keys: ["definitionOfReady", "definition_of_ready"],
-    option: "--definition-of-ready <value>",
-    description: "Definition of ready (allow empty string)",
-    aliasOptions: [{ option: "--definition_of_ready <value>", description: "Alias for --definition-of-ready" }]
-  },
-  { target: "order", keys: ["order"], option: "--order <value>", description: "Planning order/rank integer" },
-  { target: "rank", keys: ["rank"], option: "--rank <value>", description: "Alias for --order" },
-  { target: "goal", keys: ["goal"], option: "--goal <value>", description: "Goal identifier" },
-  { target: "objective", keys: ["objective"], option: "--objective <value>", description: "Objective identifier" },
-  { target: "value", keys: ["value"], option: "--value <value>", description: "Business value summary" },
-  { target: "impact", keys: ["impact"], option: "--impact <value>", description: "Business impact summary" },
-  { target: "outcome", keys: ["outcome"], option: "--outcome <value>", description: "Expected outcome summary" },
-  {
-    target: "whyNow",
-    keys: ["whyNow", "why_now"],
-    option: "--why-now <value>",
-    description: "Why-now rationale",
-    aliasOptions: [{ option: "--why_now <value>", description: "Alias for --why-now" }]
-  },
-  { target: "author", keys: ["author"], option: "--author <value>", description: "Mutation author" },
-  { target: "message", keys: ["message"], option: "--message <value>", description: "History message (allow empty string)" },
-  { target: "assignee", keys: ["assignee"], option: "--assignee <value>", description: "Item assignee" },
-  { target: "parent", keys: ["parent"], option: "--parent <value>", description: "Parent item ID" },
-  { target: "allowMissingParent", keys: ["allowMissingParent", "allow_missing_parent"], option: "--allow-missing-parent", description: "Allow creating with an unresolved parent reference and emit a validation warning" },
-  { target: "reviewer", keys: ["reviewer"], option: "--reviewer <value>", description: "Reviewer" },
-  { target: "risk", keys: ["risk"], option: "--risk <value>", description: "Risk level: low|med|medium|high|critical (med persists as medium)" },
-  {
-    target: "confidence",
-    keys: ["confidence"],
-    option: "--confidence <value>",
-    description: "Confidence level: 0..100|low|med|medium|high (med persists as medium)"
-  },
-  { target: "sprint", keys: ["sprint"], option: "--sprint <value>", description: "Sprint identifier" },
-  { target: "release", keys: ["release"], option: "--release <value>", description: "Release identifier" },
-  {
-    target: "blockedBy",
-    keys: ["blockedBy", "blocked_by"],
-    option: "--blocked-by <value>",
-    description: "Blocked-by item ID or reason",
-    aliasOptions: [{ option: "--blocked_by <value>", description: "Alias for --blocked-by" }]
-  },
-  {
-    target: "blockedReason",
-    keys: ["blockedReason", "blocked_reason"],
-    option: "--blocked-reason <value>",
-    description: "Blocked reason",
-    aliasOptions: [{ option: "--blocked_reason <value>", description: "Alias for --blocked-reason" }]
-  },
-  {
-    target: "unblockNote",
-    keys: ["unblockNote", "unblock_note"],
-    option: "--unblock-note <value>",
-    description: "Unblock rationale note",
-    aliasOptions: [{ option: "--unblock_note <value>", description: "Alias for --unblock-note" }]
-  },
-  { target: "reporter", keys: ["reporter"], option: "--reporter <value>", description: "Issue reporter" },
-  {
-    target: "severity",
-    keys: ["severity"],
-    option: "--severity <value>",
-    description: "Issue severity: low|med|medium|high|critical (med persists as medium)"
-  },
-  { target: "environment", keys: ["environment"], option: "--environment <value>", description: "Issue environment context" },
-  {
-    target: "reproSteps",
-    keys: ["reproSteps", "repro_steps"],
-    option: "--repro-steps <value>",
-    description: "Issue reproduction steps",
-    aliasOptions: [{ option: "--repro_steps <value>", description: "Alias for --repro-steps" }]
-  },
-  { target: "resolution", keys: ["resolution"], option: "--resolution <value>", description: "Issue resolution summary" },
-  {
-    target: "expectedResult",
-    keys: ["expectedResult", "expected_result", "expected"],
-    option: "--expected-result <value>",
-    description: "Issue expected behavior",
-    aliasOptions: [
-      { option: "--expected_result <value>", description: "Alias for --expected-result" },
-      { option: "--expected <value>", description: "Short alias for --expected-result" }
-    ]
-  },
-  {
-    target: "actualResult",
-    keys: ["actualResult", "actual_result", "actual"],
-    option: "--actual-result <value>",
-    description: "Issue observed behavior",
-    aliasOptions: [
-      { option: "--actual_result <value>", description: "Alias for --actual-result" },
-      { option: "--actual <value>", description: "Short alias for --actual-result" }
-    ]
-  },
-  {
-    target: "affectedVersion",
-    keys: ["affectedVersion", "affected_version"],
-    option: "--affected-version <value>",
-    description: "Affected version identifier",
-    aliasOptions: [{ option: "--affected_version <value>", description: "Alias for --affected-version" }]
-  },
-  {
-    target: "fixedVersion",
-    keys: ["fixedVersion", "fixed_version"],
-    option: "--fixed-version <value>",
-    description: "Fixed version identifier",
-    aliasOptions: [{ option: "--fixed_version <value>", description: "Alias for --fixed-version" }]
-  },
-  { target: "component", keys: ["component"], option: "--component <value>", description: "Issue component ownership" },
-  { target: "regression", keys: ["regression"], option: "--regression <value>", description: "Regression marker: true|false|1|0" },
-  {
-    target: "customerImpact",
-    keys: ["customerImpact", "customer_impact"],
-    option: "--customer-impact <value>",
-    description: "Customer impact summary",
-    aliasOptions: [{ option: "--customer_impact <value>", description: "Alias for --customer-impact" }]
-  },
-  {
-    target: "dep",
-    keys: ["dep"],
-    option: "--dep <value>",
-    description: "Seed dependency entry (key=value CSV, markdown key:value lines, or - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "typeOption",
-    keys: ["typeOption", "type_option"],
-    option: "--type-option <value>",
-    description: "Type option key=value or key=<name>,value=<value> (also accepts key:value and markdown pairs; use - for stdin; repeatable)",
-    repeatable: true,
-    aliasOptions: [{ option: "--type_option <value>", description: "Alias for --type-option" }]
-  },
-  {
-    target: "field",
-    keys: ["field"],
-    option: "--field <name=value>",
-    description: "Set a field declared by an active extension registerItemFields registration (repeatable)",
-    repeatable: true
-  },
-  {
-    target: "unset",
-    keys: ["unset"],
-    option: "--unset <field>",
-    description: "Clear scalar metadata field by name (repeatable)",
-    repeatable: true
-  },
-  {
-    target: "reminder",
-    keys: ["reminder"],
-    option: "--reminder <value>",
-    description: "Seed reminder entry at=<iso|relative>,text=<text> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "event",
-    keys: ["event"],
-    option: "--event <value>",
-    description: "Seed event entry start=<iso|relative>,end=<iso|relative>,duration=<relative|30min|PT30M>,title=<text>,all_day=<true|false>,recur_* fields (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "comment",
-    keys: ["comment"],
-    option: "--comment <value>",
-    description: "Seed comment entry (text=<value> CSV/markdown pairs or - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "note",
-    keys: ["note"],
-    option: "--note <value>",
-    description: "Seed note entry (text=<value> CSV/markdown pairs or - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "learning",
-    keys: ["learning"],
-    option: "--learning <value>",
-    description: "Seed learning entry (text=<value> CSV/markdown pairs or - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "file",
-    keys: ["file"],
-    option: "--file <value>",
-    description: "Seed linked file entry (CSV/markdown pairs or - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "test",
-    keys: ["test"],
-    option: "--test <value>",
-    description: "Seed linked test entry (CSV/markdown pairs or - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "doc",
-    keys: ["doc"],
-    option: "--doc <value>",
-    description: "Seed linked doc entry (CSV/markdown pairs or - for stdin; repeatable)",
-    repeatable: true
-  }
-];
-var CREATE_COMMANDER_STRING_OPTION_CONTRACTS = CREATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS.filter((entry) => entry.repeatable !== true).map((entry) => ({ target: entry.target, keys: entry.keys }));
-var CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS = CREATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS.filter((entry) => entry.repeatable === true).map((entry) => ({ target: entry.target, keys: entry.keys }));
-var UPDATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS = [
-  { target: "title", keys: ["title"], option: "--title, -t <value>", description: "Set title" },
-  { target: "description", keys: ["description"], option: "--description, -d <value>", description: "Set description" },
-  { target: "body", keys: ["body"], option: "--body, -b <value>", description: "Set body (allow empty string)" },
-  { target: "status", keys: ["status"], option: "--status, -s <value>", description: "Set status (use close command for closed)" },
-  {
-    target: "closeReason",
-    keys: ["closeReason", "close_reason"],
-    option: "--close-reason <value>",
-    description: "Set close reason",
-    aliasOptions: [{ option: "--close_reason <value>", description: "Alias for --close-reason" }]
-  },
-  { target: "priority", keys: ["priority"], option: "--priority, -p <value>", description: "Set priority" },
-  { target: "type", keys: ["type"], option: "--type <value>", description: "Set type" },
-  { target: "tags", keys: ["tags"], option: "--tags <value>", description: "Set comma-separated tags (replaces existing). Use --add-tags / --remove-tags to mutate additively." },
-  {
-    target: "addTags",
-    keys: ["addTags", "add_tags"],
-    option: "--add-tags <value>",
-    description: "Add tags to the existing list without replacing it (repeatable; CSV accepted)",
-    repeatable: true,
-    aliasOptions: [{ option: "--add_tags <value>", description: "Alias for --add-tags" }]
-  },
-  {
-    target: "removeTags",
-    keys: ["removeTags", "remove_tags"],
-    option: "--remove-tags <value>",
-    description: "Remove tags from the existing list (repeatable; CSV accepted)",
-    repeatable: true,
-    aliasOptions: [{ option: "--remove_tags <value>", description: "Alias for --remove-tags" }]
-  },
-  { target: "deadline", keys: ["deadline"], option: "--deadline <value>", description: "Set deadline (ISO/date string or relative)" },
-  {
-    target: "estimatedMinutes",
-    keys: ["estimate", "estimatedMinutes", "estimated_minutes"],
-    option: "--estimate, --estimated-minutes <value>",
-    description: "Set estimated minutes",
-    aliasOptions: [{ option: "--estimated_minutes <value>", description: "Alias for --estimated-minutes" }]
-  },
-  {
-    target: "acceptanceCriteria",
-    keys: ["acceptanceCriteria", "acceptance_criteria", "ac"],
-    option: "--acceptance-criteria <value>",
-    description: "Set acceptance criteria",
-    aliasOptions: [
-      { option: "--acceptance_criteria <value>", description: "Alias for --acceptance-criteria" },
-      { option: "--ac <value>", description: "Alias for --acceptance-criteria" }
-    ]
-  },
-  {
-    target: "definitionOfReady",
-    keys: ["definitionOfReady", "definition_of_ready"],
-    option: "--definition-of-ready <value>",
-    description: "Set definition of ready",
-    aliasOptions: [{ option: "--definition_of_ready <value>", description: "Alias for --definition-of-ready" }]
-  },
-  { target: "order", keys: ["order"], option: "--order <value>", description: "Set planning order/rank integer" },
-  { target: "rank", keys: ["rank"], option: "--rank <value>", description: "Alias for --order" },
-  { target: "goal", keys: ["goal"], option: "--goal <value>", description: "Set goal identifier" },
-  { target: "objective", keys: ["objective"], option: "--objective <value>", description: "Set objective identifier" },
-  { target: "value", keys: ["value"], option: "--value <value>", description: "Set business value summary" },
-  { target: "impact", keys: ["impact"], option: "--impact <value>", description: "Set business impact summary" },
-  { target: "outcome", keys: ["outcome"], option: "--outcome <value>", description: "Set expected outcome summary" },
-  {
-    target: "whyNow",
-    keys: ["whyNow", "why_now"],
-    option: "--why-now <value>",
-    description: "Set why-now rationale",
-    aliasOptions: [{ option: "--why_now <value>", description: "Alias for --why-now" }]
-  },
-  { target: "author", keys: ["author"], option: "--author <value>", description: "Mutation author" },
-  { target: "message", keys: ["message"], option: "--message <value>", description: "Mutation message" },
-  { target: "assignee", keys: ["assignee"], option: "--assignee <value>", description: "Set assignee" },
-  { target: "parent", keys: ["parent"], option: "--parent <value>", description: "Set parent item ID" },
-  { target: "reviewer", keys: ["reviewer"], option: "--reviewer <value>", description: "Set reviewer" },
-  { target: "risk", keys: ["risk"], option: "--risk <value>", description: "Set risk level: low|med|medium|high|critical (med persists as medium)" },
-  {
-    target: "confidence",
-    keys: ["confidence"],
-    option: "--confidence <value>",
-    description: "Set confidence level: 0..100|low|med|medium|high (med persists as medium)"
-  },
-  { target: "sprint", keys: ["sprint"], option: "--sprint <value>", description: "Set sprint identifier" },
-  { target: "release", keys: ["release"], option: "--release <value>", description: "Set release identifier" },
-  {
-    target: "blockedBy",
-    keys: ["blockedBy", "blocked_by"],
-    option: "--blocked-by <value>",
-    description: "Set blocked-by item ID or reason",
-    aliasOptions: [{ option: "--blocked_by <value>", description: "Alias for --blocked-by" }]
-  },
-  {
-    target: "blockedReason",
-    keys: ["blockedReason", "blocked_reason"],
-    option: "--blocked-reason <value>",
-    description: "Set blocked reason",
-    aliasOptions: [{ option: "--blocked_reason <value>", description: "Alias for --blocked-reason" }]
-  },
-  {
-    target: "unblockNote",
-    keys: ["unblockNote", "unblock_note"],
-    option: "--unblock-note <value>",
-    description: "Set unblock rationale note",
-    aliasOptions: [{ option: "--unblock_note <value>", description: "Alias for --unblock-note" }]
-  },
-  { target: "reporter", keys: ["reporter"], option: "--reporter <value>", description: "Set issue reporter" },
-  {
-    target: "severity",
-    keys: ["severity"],
-    option: "--severity <value>",
-    description: "Set issue severity: low|med|medium|high|critical (med persists as medium)"
-  },
-  { target: "environment", keys: ["environment"], option: "--environment <value>", description: "Set issue environment context" },
-  {
-    target: "reproSteps",
-    keys: ["reproSteps", "repro_steps"],
-    option: "--repro-steps <value>",
-    description: "Set issue reproduction steps",
-    aliasOptions: [{ option: "--repro_steps <value>", description: "Alias for --repro-steps" }]
-  },
-  { target: "resolution", keys: ["resolution"], option: "--resolution <value>", description: "Set issue resolution summary" },
-  {
-    target: "expectedResult",
-    keys: ["expectedResult", "expected_result", "expected"],
-    option: "--expected-result <value>",
-    description: "Set issue expected behavior",
-    aliasOptions: [
-      { option: "--expected_result <value>", description: "Alias for --expected-result" },
-      { option: "--expected <value>", description: "Short alias for --expected-result" }
-    ]
-  },
-  {
-    target: "actualResult",
-    keys: ["actualResult", "actual_result", "actual"],
-    option: "--actual-result <value>",
-    description: "Set issue observed behavior",
-    aliasOptions: [
-      { option: "--actual_result <value>", description: "Alias for --actual-result" },
-      { option: "--actual <value>", description: "Short alias for --actual-result" }
-    ]
-  },
-  {
-    target: "affectedVersion",
-    keys: ["affectedVersion", "affected_version"],
-    option: "--affected-version <value>",
-    description: "Set affected version identifier",
-    aliasOptions: [{ option: "--affected_version <value>", description: "Alias for --affected-version" }]
-  },
-  {
-    target: "fixedVersion",
-    keys: ["fixedVersion", "fixed_version"],
-    option: "--fixed-version <value>",
-    description: "Set fixed version identifier",
-    aliasOptions: [{ option: "--fixed_version <value>", description: "Alias for --fixed-version" }]
-  },
-  { target: "component", keys: ["component"], option: "--component <value>", description: "Set issue component ownership" },
-  { target: "regression", keys: ["regression"], option: "--regression <value>", description: "Set regression marker: true|false|1|0" },
-  {
-    target: "customerImpact",
-    keys: ["customerImpact", "customer_impact"],
-    option: "--customer-impact <value>",
-    description: "Set customer impact summary",
-    aliasOptions: [{ option: "--customer_impact <value>", description: "Alias for --customer-impact" }]
-  },
-  {
-    target: "dep",
-    keys: ["dep"],
-    option: "--dep <value>",
-    description: "Add dependency entries id=<id>,kind=<value>,author=<value>,created_at=<iso|now>,source_kind=<value> (repeatable)",
-    repeatable: true
-  },
-  {
-    target: "depRemove",
-    keys: ["depRemove", "dep_remove"],
-    option: "--dep-remove <value>",
-    description: "Remove dependencies by id or id=<id>,kind=<value>,source_kind=<value> selectors (repeatable)",
-    repeatable: true,
-    aliasOptions: [{ option: "--dep_remove <value>", description: "Alias for --dep-remove" }]
-  },
-  {
-    target: "comment",
-    keys: ["comment"],
-    option: "--comment <value>",
-    description: "Append comment seed author=<value>,created_at=<iso|now>,text=<value> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "note",
-    keys: ["note"],
-    option: "--note <value>",
-    description: "Append note seed author=<value>,created_at=<iso|now>,text=<value> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "learning",
-    keys: ["learning"],
-    option: "--learning <value>",
-    description: "Append learning seed author=<value>,created_at=<iso|now>,text=<value> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "file",
-    keys: ["file"],
-    option: "--file <value>",
-    description: "Append linked file path=<value>,scope=<project|global>,note=<text> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "test",
-    keys: ["test"],
-    option: "--test <value>",
-    description: "Append linked test command=<value>,path=<value>,scope=<project|global>,timeout_seconds=<n>,pm_context_mode=<schema|tracker|auto> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "doc",
-    keys: ["doc"],
-    option: "--doc <value>",
-    description: "Append linked doc path=<value>,scope=<project|global>,note=<text> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "reminder",
-    keys: ["reminder"],
-    option: "--reminder <value>",
-    description: "Set reminders at=<iso|relative>,text=<text> (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "event",
-    keys: ["event"],
-    option: "--event <value>",
-    description: "Set events start=<iso|relative>,end=<iso|relative>,duration=<relative|30min|PT30M>,title=<text>,all_day=<true|false>,recur_* fields (also accepts markdown pairs and - for stdin; repeatable)",
-    repeatable: true
-  },
-  {
-    target: "typeOption",
-    keys: ["typeOption", "type_option"],
-    option: "--type-option <value>",
-    description: "Set type options key=value or key=<name>,value=<value> (also accepts key:value and markdown pairs; use - for stdin; repeatable)",
-    repeatable: true,
-    aliasOptions: [{ option: "--type_option <value>", description: "Alias for --type-option" }]
-  },
-  {
-    target: "field",
-    keys: ["field"],
-    option: "--field <name=value>",
-    description: "Set a field declared by an active extension registerItemFields registration (repeatable)",
-    repeatable: true
-  },
-  {
-    target: "unset",
-    keys: ["unset"],
-    option: "--unset <field>",
-    description: "Clear scalar metadata field by name (repeatable)",
-    repeatable: true
-  }
-];
-var UPDATE_COMMANDER_STRING_OPTION_CONTRACTS = UPDATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS.filter((entry) => entry.repeatable !== true).map((entry) => ({ target: entry.target, keys: entry.keys }));
-var UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS = UPDATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS.filter((entry) => entry.repeatable === true).map((entry) => ({ target: entry.target, keys: entry.keys }));
-
-// dist/sdk/cli-contracts/enum-contracts.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] = "6c161a7b-d1ca-5ed2-8348-024739a81bc4");
-  } catch (e2) {
-  }
-})();
-var PM_EXTENSION_CAPABILITY_CONTRACTS = [...KNOWN_EXTENSION_CAPABILITIES];
-var PM_EXTENSION_SERVICE_NAME_CONTRACTS = [...KNOWN_EXTENSION_SERVICE_NAMES];
-var PM_EXTENSION_POLICY_MODE_CONTRACTS = [...KNOWN_EXTENSION_POLICY_MODES];
-var PM_EXTENSION_TRUST_MODE_CONTRACTS = [...KNOWN_EXTENSION_TRUST_MODES];
-var PM_EXTENSION_SANDBOX_PROFILE_CONTRACTS = [...KNOWN_EXTENSION_SANDBOX_PROFILES];
-var PM_EXTENSION_POLICY_SURFACE_CONTRACTS = [...KNOWN_EXTENSION_POLICY_SURFACES];
-var PM_CORE_COMMAND_NAMES = [
-  "init",
-  "config",
-  "extension",
-  "package",
-  "packages",
-  "install",
-  "upgrade",
-  "create",
-  "copy",
-  "focus",
-  "list",
-  "list-all",
-  "list-draft",
-  "list-open",
-  "list-in-progress",
-  "list-blocked",
-  "list-closed",
-  "list-canceled",
-  "aggregate",
-  "context",
-  "ctx",
-  "get",
-  "search",
-  "eval",
-  "next",
-  "history",
-  "history-redact",
-  "history-repair",
-  "history-compact",
-  "schema",
-  "profile",
-  "activity",
-  "restore",
-  "update",
-  "update-many",
-  "close",
-  "close-many",
-  "delete",
-  "append",
-  "comments",
-  "notes",
-  "learnings",
-  "files",
-  "docs",
-  "deps",
-  "plan",
-  "test",
-  "test-all",
-  "telemetry",
-  "stats",
-  "health",
-  "validate",
-  "gc",
-  "contracts",
-  "claim",
-  "release",
-  "start-task",
-  "pause-task",
-  "close-task",
-  "meet",
-  "event",
-  "remind",
-  "help"
-];
-var PM_TOOL_ACTIONS = [
-  "init",
-  "config",
-  "extension-init",
-  "extension-install",
-  "extension-uninstall",
-  "extension-explore",
-  "extension-manage",
-  "extension-describe",
-  "extension-reload",
-  "extension-doctor",
-  "extension-catalog",
-  "extension-adopt",
-  "extension-adopt-all",
-  "extension-activate",
-  "extension-deactivate",
-  "extension",
-  "package-init",
-  "package-install",
-  "package-uninstall",
-  "package-explore",
-  "package-manage",
-  "package-describe",
-  "package-reload",
-  "package-doctor",
-  "package-catalog",
-  "package-adopt",
-  "package-adopt-all",
-  "package-activate",
-  "package-deactivate",
-  "package",
-  "install",
-  "upgrade",
-  "create",
-  "copy",
-  "focus",
-  "list",
-  "list-all",
-  "list-draft",
-  "list-open",
-  "list-in-progress",
-  "list-blocked",
-  "list-closed",
-  "list-canceled",
-  "aggregate",
-  "context",
-  "ctx",
-  "get",
-  "search",
-  "next",
-  "history",
-  "history-redact",
-  "history-repair",
-  "history-compact",
-  "schema",
-  "profile",
-  "activity",
-  "restore",
-  "update",
-  "update-many",
-  "close",
-  "close-many",
-  "delete",
-  "append",
-  "comments",
-  "plan",
-  "notes",
-  "learnings",
-  "files",
-  "docs",
-  "deps",
-  "test",
-  "test-all",
-  "telemetry",
-  "stats",
-  "health",
-  "validate",
-  "gc",
-  "contracts",
-  "claim",
-  "release",
-  "start-task",
-  "pause-task",
-  "close-task"
-];
-function isPmToolAction(value) {
-  return PM_TOOL_ACTIONS.includes(value);
-}
-function isPmExtensionCapabilityContract(value) {
-  return PM_EXTENSION_CAPABILITY_CONTRACTS.includes(value);
-}
-function isPmExtensionServiceNameContract(value) {
-  return PM_EXTENSION_SERVICE_NAME_CONTRACTS.includes(value);
-}
-function isPmExtensionPolicyModeContract(value) {
-  return PM_EXTENSION_POLICY_MODE_CONTRACTS.includes(value);
-}
-function isPmExtensionPolicySurfaceContract(value) {
-  return PM_EXTENSION_POLICY_SURFACE_CONTRACTS.includes(value);
-}
-
-// dist/sdk/cli-contracts/tool-option-contracts.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] = "e6388be4-3b86-52cb-8bd3-9fafaed43195");
-  } catch (e2) {
-  }
-})();
-function cloneOptionContracts(contracts) {
-  return contracts.map((contract) => ({ ...contract }));
-}
-var TOOL_ITEM_BASE_FILTER_OPTION_CONTRACTS = [
-  { param: "status", flag: "--status" },
-  { param: "type", flag: "--type" },
-  { param: "tag", flag: "--tag" },
-  { param: "priority", flag: "--priority" },
-  { param: "deadlineBefore", flag: "--deadline-before" },
-  { param: "deadlineAfter", flag: "--deadline-after" }
-];
-var TOOL_ITEM_WINDOW_FILTER_OPTION_CONTRACTS = [
-  { param: "updatedAfter", flag: "--updated-after" },
-  { param: "updatedBefore", flag: "--updated-before" },
-  { param: "createdAfter", flag: "--created-after" },
-  { param: "createdBefore", flag: "--created-before" }
-];
-var TOOL_ITEM_RELATION_FILTER_OPTION_CONTRACTS = [
-  { param: "assignee", flag: "--assignee" },
-  { param: "assigneeFilter", flag: "--assignee-filter" },
-  { param: "parent", flag: "--parent" },
-  { param: "sprint", flag: "--sprint" },
-  { param: "release", flag: "--release" }
-];
-var TOOL_SEARCH_RELATION_FILTER_OPTION_CONTRACTS = [
-  { param: "assignee", flag: "--assignee" },
-  { param: "sprint", flag: "--sprint" },
-  { param: "release", flag: "--release" },
-  { param: "parent", flag: "--parent" }
-];
-var TOOL_BASIC_ITEM_FILTER_OPTION_CONTRACTS = [
-  ...TOOL_ITEM_BASE_FILTER_OPTION_CONTRACTS,
-  ...TOOL_ITEM_RELATION_FILTER_OPTION_CONTRACTS
-];
-var TOOL_GOVERNANCE_MISSING_OPTION_CONTRACTS = [
-  { param: "filterReviewerMissing", flag: "--filter-reviewer-missing" },
-  { param: "filterRiskMissing", flag: "--filter-risk-missing" },
-  { param: "filterConfidenceMissing", flag: "--filter-confidence-missing" },
-  { param: "filterSprintMissing", flag: "--filter-sprint-missing" },
-  { param: "filterReleaseMissing", flag: "--filter-release-missing" }
-];
-var TOOL_CONTENT_PRESENCE_OPTION_CONTRACTS = [
-  { param: "hasNotes", flag: "--has-notes" },
-  { param: "noNotes", flag: "--no-notes" },
-  { param: "hasLearnings", flag: "--has-learnings" },
-  { param: "noLearnings", flag: "--no-learnings" },
-  { param: "hasFiles", flag: "--has-files" },
-  { param: "noFiles", flag: "--no-files" },
-  { param: "filterFilesMissing", flag: "--filter-files-missing" },
-  { param: "hasDocs", flag: "--has-docs" },
-  { param: "noDocs", flag: "--no-docs" },
-  { param: "filterDocsMissing", flag: "--filter-docs-missing" },
-  { param: "hasTests", flag: "--has-tests" },
-  { param: "noTests", flag: "--no-tests" },
-  { param: "hasComments", flag: "--has-comments" },
-  { param: "noComments", flag: "--no-comments" },
-  { param: "hasDeps", flag: "--has-deps" },
-  { param: "noDeps", flag: "--no-deps" },
-  { param: "hasBody", flag: "--has-body" },
-  { param: "emptyBody", flag: "--empty-body" },
-  { param: "hasLinkedCommand", flag: "--has-linked-command" },
-  { param: "noLinkedCommand", flag: "--no-linked-command" }
-];
-var TOOL_LIST_FILTER_OPTION_CONTRACTS = [
-  ...cloneOptionContracts(TOOL_ITEM_BASE_FILTER_OPTION_CONTRACTS),
-  ...cloneOptionContracts(TOOL_ITEM_WINDOW_FILTER_OPTION_CONTRACTS),
-  { param: "ids", flag: "--ids" },
-  ...cloneOptionContracts(TOOL_ITEM_RELATION_FILTER_OPTION_CONTRACTS),
-  { param: "filterAcMissing", flag: "--filter-ac-missing" },
-  { param: "filterEstimatesMissing", flag: "--filter-estimates-missing" },
-  { param: "filterResolutionMissing", flag: "--filter-resolution-missing" },
-  { param: "filterMetadataMissing", flag: "--filter-metadata-missing" },
-  ...cloneOptionContracts(TOOL_GOVERNANCE_MISSING_OPTION_CONTRACTS),
-  ...cloneOptionContracts(TOOL_CONTENT_PRESENCE_OPTION_CONTRACTS),
-  { param: "limit", flag: "--limit" },
-  { param: "offset", flag: "--offset" },
-  { param: "fields", flag: "--fields" },
-  { param: "sort", flag: "--sort" },
-  { param: "order", flag: "--order" },
-  { param: "tree", flag: "--tree" },
-  { param: "treeDepth", flag: "--tree-depth" }
-];
-var TOOL_AGGREGATE_OPTION_CONTRACTS = [
-  { param: "groupBy", flag: "--group-by" },
-  { param: "sum", flag: "--sum" },
-  { param: "avg", flag: "--avg" },
-  ...cloneOptionContracts(TOOL_BASIC_ITEM_FILTER_OPTION_CONTRACTS)
-];
-var TOOL_DEDUPE_AUDIT_OPTION_CONTRACTS = [
-  { param: "mode", flag: "--mode" },
-  { param: "limit", flag: "--limit" },
-  { param: "threshold", flag: "--threshold" },
-  ...cloneOptionContracts(TOOL_BASIC_ITEM_FILTER_OPTION_CONTRACTS)
-];
-var TOOL_SEARCH_FILTER_OPTION_CONTRACTS = [
-  { param: "matchMode", flag: "--match-mode" },
-  { param: "minScore", flag: "--min-score" },
-  { param: "count", flag: "--count", booleanish: true },
-  { param: "semanticWeight", flag: "--semantic-weight" },
-  ...cloneOptionContracts(TOOL_ITEM_BASE_FILTER_OPTION_CONTRACTS),
-  ...cloneOptionContracts(TOOL_ITEM_WINDOW_FILTER_OPTION_CONTRACTS),
-  ...cloneOptionContracts(TOOL_SEARCH_RELATION_FILTER_OPTION_CONTRACTS),
-  ...cloneOptionContracts(TOOL_GOVERNANCE_MISSING_OPTION_CONTRACTS),
-  ...cloneOptionContracts(TOOL_CONTENT_PRESENCE_OPTION_CONTRACTS),
-  { param: "fields", flag: "--fields" },
-  { param: "limit", flag: "--limit" }
-];
-var TOOL_SHARED_CREATE_UPDATE_OPTION_CONTRACTS = [
-  { param: "parent", flag: "--parent" },
-  { param: "reviewer", flag: "--reviewer" },
-  { param: "risk", flag: "--risk" },
-  { param: "confidence", flag: "--confidence" },
-  { param: "sprint", flag: "--sprint" },
-  { param: "release", flag: "--release" },
-  { param: "blockedBy", flag: "--blocked-by" },
-  { param: "blockedReason", flag: "--blocked-reason" },
-  { param: "unblockNote", flag: "--unblock-note" },
-  { param: "reporter", flag: "--reporter" },
-  { param: "severity", flag: "--severity" },
-  { param: "environment", flag: "--environment" },
-  { param: "reproSteps", flag: "--repro-steps" },
-  { param: "resolution", flag: "--resolution" },
-  { param: "expectedResult", flag: "--expected-result" },
-  { param: "actualResult", flag: "--actual-result" },
-  { param: "affectedVersion", flag: "--affected-version" },
-  { param: "fixedVersion", flag: "--fixed-version" },
-  { param: "component", flag: "--component" },
-  { param: "regression", flag: "--regression", booleanish: true },
-  { param: "customerImpact", flag: "--customer-impact" },
-  { param: "definitionOfReady", flag: "--definition-of-ready", allowEmpty: true },
-  { param: "order", flag: "--order" },
-  { param: "goal", flag: "--goal" },
-  { param: "objective", flag: "--objective" },
-  { param: "value", flag: "--value" },
-  { param: "impact", flag: "--impact" },
-  { param: "outcome", flag: "--outcome" },
-  { param: "whyNow", flag: "--why-now" }
-];
-var TOOL_CREATE_OPTION_CONTRACTS = [
-  { param: "title", flag: "--title" },
-  { param: "description", flag: "--description", allowEmpty: true },
-  { param: "type", flag: "--type" },
-  { param: "template", flag: "--template" },
-  { param: "createMode", flag: "--create-mode" },
-  { param: "schedulePreset", flag: "--schedule-preset" },
-  { param: "status", flag: "--status" },
-  { param: "priority", flag: "--priority" },
-  { param: "tags", flag: "--tags", allowEmpty: true },
-  { param: "addTags", flag: "--add-tags", repeatable: true },
-  { param: "body", flag: "--body", allowEmpty: true },
-  { param: "deadline", flag: "--deadline" },
-  { param: "estimate", flag: "--estimate" },
-  { param: "acceptanceCriteria", flag: "--acceptance-criteria", allowEmpty: true },
-  { param: "author", flag: "--author" },
-  { param: "message", flag: "--message", allowEmpty: true },
-  { param: "assignee", flag: "--assignee" },
-  { param: "allowMissingParent", flag: "--allow-missing-parent" },
-  { param: "reminder", flag: "--reminder", repeatable: true },
-  { param: "event", flag: "--event", repeatable: true },
-  { param: "typeOption", flag: "--type-option", repeatable: true },
-  { param: "field", flag: "--field", repeatable: true },
-  { param: "dep", flag: "--dep", repeatable: true },
-  { param: "comment", flag: "--comment", repeatable: true },
-  { param: "note", flag: "--note", repeatable: true },
-  { param: "learning", flag: "--learning", repeatable: true },
-  { param: "linkedFile", flag: "--file", repeatable: true },
-  { param: "linkedTest", flag: "--test", repeatable: true },
-  { param: "doc", flag: "--doc", repeatable: true },
-  { param: "unset", flag: "--unset", repeatable: true },
-  { param: "clearDeps", flag: "--clear-deps" },
-  { param: "clearComments", flag: "--clear-comments" },
-  { param: "clearNotes", flag: "--clear-notes" },
-  { param: "clearLearnings", flag: "--clear-learnings" },
-  { param: "clearFiles", flag: "--clear-files" },
-  { param: "clearTests", flag: "--clear-tests" },
-  { param: "clearDocs", flag: "--clear-docs" },
-  { param: "clearReminders", flag: "--clear-reminders" },
-  { param: "clearEvents", flag: "--clear-events" },
-  { param: "clearTypeOptions", flag: "--clear-type-options" }
-];
-var TOOL_UPDATE_OPTION_CONTRACTS = [
-  { param: "title", flag: "--title" },
-  { param: "description", flag: "--description", allowEmpty: true },
-  { param: "body", flag: "--body", allowEmpty: true },
-  { param: "status", flag: "--status" },
-  { param: "closeReason", flag: "--close-reason" },
-  { param: "priority", flag: "--priority" },
-  { param: "type", flag: "--type" },
-  { param: "tags", flag: "--tags", allowEmpty: true },
-  { param: "addTags", flag: "--add-tags", repeatable: true },
-  { param: "removeTags", flag: "--remove-tags", repeatable: true },
-  { param: "deadline", flag: "--deadline" },
-  { param: "estimate", flag: "--estimate" },
-  { param: "acceptanceCriteria", flag: "--acceptance-criteria", allowEmpty: true },
-  { param: "author", flag: "--author" },
-  { param: "message", flag: "--message", allowEmpty: true },
-  { param: "assignee", flag: "--assignee" },
-  { param: "dep", flag: "--dep", repeatable: true },
-  { param: "depRemove", flag: "--dep-remove", repeatable: true },
-  { param: "replaceDeps", flag: "--replace-deps" },
-  { param: "replaceTests", flag: "--replace-tests" },
-  { param: "comment", flag: "--comment", repeatable: true },
-  { param: "note", flag: "--note", repeatable: true },
-  { param: "learning", flag: "--learning", repeatable: true },
-  { param: "linkedFile", flag: "--file", repeatable: true },
-  { param: "linkedTest", flag: "--test", repeatable: true },
-  { param: "doc", flag: "--doc", repeatable: true },
-  { param: "reminder", flag: "--reminder", repeatable: true },
-  { param: "event", flag: "--event", repeatable: true },
-  { param: "typeOption", flag: "--type-option", repeatable: true },
-  { param: "field", flag: "--field", repeatable: true },
-  { param: "unset", flag: "--unset", repeatable: true },
-  { param: "clearDeps", flag: "--clear-deps" },
-  { param: "clearComments", flag: "--clear-comments" },
-  { param: "clearNotes", flag: "--clear-notes" },
-  { param: "clearLearnings", flag: "--clear-learnings" },
-  { param: "clearFiles", flag: "--clear-files" },
-  { param: "clearTests", flag: "--clear-tests" },
-  { param: "clearDocs", flag: "--clear-docs" },
-  { param: "clearReminders", flag: "--clear-reminders" },
-  { param: "clearEvents", flag: "--clear-events" },
-  { param: "clearTypeOptions", flag: "--clear-type-options" },
-  { param: "allowAuditUpdate", flag: "--allow-audit-update" },
-  { param: "allowAuditDepUpdate", flag: "--allow-audit-dep-update" }
-];
-var TOOL_BULK_MUTATION_FILTER_OPTION_CONTRACTS = [
-  { param: "filterStatus", flag: "--filter-status" },
-  { param: "filterType", flag: "--filter-type" },
-  { param: "filterTag", flag: "--filter-tag" },
-  { param: "filterPriority", flag: "--filter-priority" },
-  { param: "filterDeadlineBefore", flag: "--filter-deadline-before" },
-  { param: "filterDeadlineAfter", flag: "--filter-deadline-after" },
-  { param: "filterUpdatedAfter", flag: "--filter-updated-after" },
-  { param: "filterUpdatedBefore", flag: "--filter-updated-before" },
-  { param: "filterCreatedAfter", flag: "--filter-created-after" },
-  { param: "filterCreatedBefore", flag: "--filter-created-before" },
-  { param: "filterAssignee", flag: "--filter-assignee" },
-  { param: "filterAssigneeFilter", flag: "--filter-assignee-filter" },
-  { param: "filterParent", flag: "--filter-parent" },
-  { param: "filterSprint", flag: "--filter-sprint" },
-  { param: "filterRelease", flag: "--filter-release" },
-  { param: "filterReviewerMissing", flag: "--filter-reviewer-missing" },
-  { param: "filterRiskMissing", flag: "--filter-risk-missing" },
-  { param: "filterConfidenceMissing", flag: "--filter-confidence-missing" },
-  { param: "filterSprintMissing", flag: "--filter-sprint-missing" },
-  { param: "filterReleaseMissing", flag: "--filter-release-missing" },
-  { param: "filterHasNotes", flag: "--filter-has-notes" },
-  { param: "filterNoNotes", flag: "--filter-no-notes" },
-  { param: "filterHasLearnings", flag: "--filter-has-learnings" },
-  { param: "filterNoLearnings", flag: "--filter-no-learnings" },
-  { param: "filterHasFiles", flag: "--filter-has-files" },
-  { param: "filterNoFiles", flag: "--filter-no-files" },
-  { param: "filterHasDocs", flag: "--filter-has-docs" },
-  { param: "filterNoDocs", flag: "--filter-no-docs" },
-  { param: "filterHasTests", flag: "--filter-has-tests" },
-  { param: "filterNoTests", flag: "--filter-no-tests" },
-  { param: "filterHasComments", flag: "--filter-has-comments" },
-  { param: "filterNoComments", flag: "--filter-no-comments" },
-  { param: "filterHasDeps", flag: "--filter-has-deps" },
-  { param: "filterNoDeps", flag: "--filter-no-deps" },
-  { param: "filterHasBody", flag: "--filter-has-body" },
-  { param: "filterEmptyBody", flag: "--filter-empty-body" },
-  { param: "filterHasLinkedCommand", flag: "--filter-has-linked-command" },
-  { param: "filterNoLinkedCommand", flag: "--filter-no-linked-command" },
-  { param: "ids", flag: "--ids" },
-  { param: "limit", flag: "--limit" },
-  { param: "offset", flag: "--offset" }
-];
-var TOOL_UPDATE_MANY_FILTER_OPTION_CONTRACTS = [
-  ...cloneOptionContracts(TOOL_BULK_MUTATION_FILTER_OPTION_CONTRACTS)
-];
-var TOOL_NORMALIZE_FILTER_OPTION_CONTRACTS = [
-  { param: "filterStatus", flag: "--filter-status" },
-  { param: "filterType", flag: "--filter-type" },
-  { param: "filterTag", flag: "--filter-tag" },
-  { param: "filterPriority", flag: "--filter-priority" },
-  { param: "filterDeadlineBefore", flag: "--filter-deadline-before" },
-  { param: "filterDeadlineAfter", flag: "--filter-deadline-after" },
-  { param: "filterAssignee", flag: "--filter-assignee" },
-  { param: "filterAssigneeFilter", flag: "--filter-assignee-filter" },
-  { param: "filterParent", flag: "--filter-parent" },
-  { param: "filterSprint", flag: "--filter-sprint" },
-  { param: "filterRelease", flag: "--filter-release" },
-  { param: "limit", flag: "--limit" },
-  { param: "offset", flag: "--offset" }
-];
-var TOOL_CLOSE_MANY_FILTER_OPTION_CONTRACTS = [
-  ...cloneOptionContracts(TOOL_BULK_MUTATION_FILTER_OPTION_CONTRACTS)
-];
-var TOOL_CALENDAR_OPTION_CONTRACTS = [
-  { param: "view", flag: "--view" },
-  { param: "date", flag: "--date" },
-  { param: "from", flag: "--from" },
-  { param: "to", flag: "--to" },
-  { param: "type", flag: "--type" },
-  { param: "tag", flag: "--tag" },
-  { param: "priority", flag: "--priority" },
-  { param: "status", flag: "--status" },
-  { param: "assignee", flag: "--assignee" },
-  { param: "assigneeFilter", flag: "--assignee-filter" },
-  { param: "sprint", flag: "--sprint" },
-  { param: "release", flag: "--release" },
-  { param: "include", flag: "--include" },
-  { param: "recurrenceLookaheadDays", flag: "--recurrence-lookahead-days" },
-  { param: "recurrenceLookbackDays", flag: "--recurrence-lookback-days" },
-  { param: "occurrenceLimit", flag: "--occurrence-limit" },
-  { param: "limit", flag: "--limit" },
-  { param: "format", flag: "--format" }
-];
-var TOOL_ACTIVITY_OPTION_CONTRACTS = [
-  { param: "id", flag: "--id" },
-  { param: "op", flag: "--op" },
-  { param: "author", flag: "--author" },
-  { param: "from", flag: "--from" },
-  { param: "to", flag: "--to" },
-  { param: "limit", flag: "--limit" },
-  { param: "compact", flag: "--compact" },
-  { param: "full", flag: "--full" }
-];
-var TOOL_CONTEXT_OPTION_CONTRACTS = [
-  { param: "date", flag: "--date" },
-  { param: "from", flag: "--from" },
-  { param: "to", flag: "--to" },
-  { param: "type", flag: "--type" },
-  { param: "tag", flag: "--tag" },
-  { param: "priority", flag: "--priority" },
-  { param: "assignee", flag: "--assignee" },
-  { param: "assigneeFilter", flag: "--assignee-filter" },
-  { param: "sprint", flag: "--sprint" },
-  { param: "release", flag: "--release" },
-  { param: "parent", flag: "--parent" },
-  { param: "limit", flag: "--limit" },
-  { param: "format", flag: "--format" },
-  { param: "depth", flag: "--depth" },
-  { param: "fields", flag: "--fields" },
-  { param: "section", flag: "--section", repeatable: true },
-  { param: "activityLimit", flag: "--activity-limit" },
-  { param: "staleThreshold", flag: "--stale-threshold" }
-];
-var TOOL_DEPS_OPTION_CONTRACTS = [
-  { param: "format", flag: "--format" },
-  { param: "maxDepth", flag: "--max-depth" },
-  { param: "collapse", flag: "--collapse" },
-  { param: "summary", flag: "--summary" }
-];
-
-// dist/sdk/cli-contracts/string-lists.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] = "0a0a1dd5-dcbf-5761-9fbd-2a6295769b97");
-  } catch (e2) {
-  }
-})();
-function normalizeUniqueStringList(values) {
-  return [...new Set(Array.from(values, (value) => value.trim()).filter((value) => value.length > 0))];
-}
-
-// dist/sdk/cli-contracts/flag-contracts.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] = "811631e4-861e-5bc1-a2c8-69a78ea43e67");
-  } catch (e2) {
-  }
-})();
-function normalizeFlagAliasKey(flag) {
-  if (!flag.startsWith("--")) {
-    return flag;
-  }
-  return `--${flag.slice(2).replaceAll("_", "-")}`;
-}
-function withFlagAliasMetadata(flagContracts) {
-  const aliasesByCanonical = /* @__PURE__ */ new Map();
-  for (const contract of flagContracts) {
-    const canonical = normalizeFlagAliasKey(contract.flag);
-    const bucket = aliasesByCanonical.get(canonical) ?? /* @__PURE__ */ new Set();
-    if (contract.flag !== canonical) {
-      bucket.add(contract.flag);
-    }
-    for (const alias of contract.aliases ?? []) {
-      if (alias !== canonical) {
-        bucket.add(alias);
-      }
-    }
-    aliasesByCanonical.set(canonical, bucket);
-  }
-  return flagContracts.map((contract) => {
-    const canonical = normalizeFlagAliasKey(contract.flag);
-    if (contract.flag !== canonical) {
-      return contract;
-    }
-    const aliases = normalizeUniqueStringList([
-      ...contract.aliases ?? [],
-      ...aliasesByCanonical.get(canonical)
-    ]).filter((alias) => alias !== canonical);
-    if (aliases.length === 0) {
-      return contract;
-    }
-    return {
-      ...contract,
-      aliases
-    };
-  });
-}
-function compactFlagAliasContracts(flagContracts) {
-  const withAliases = withFlagAliasMetadata(flagContracts);
-  const canonicalFlags = new Set(withAliases.map((contract) => contract.flag));
-  return withAliases.filter((contract) => {
-    const canonical = normalizeFlagAliasKey(contract.flag);
-    return contract.flag === canonical || !canonicalFlags.has(canonical);
-  });
-}
-var SUBCOMMAND_GLOBAL_FLAG_CONTRACTS = [
-  { flag: "--json" },
-  { flag: "--quiet" },
-  { flag: "--no-changed-fields" },
-  { flag: "--id-only" },
-  { flag: "--pm-path", aliases: ["--path"] },
-  { flag: "--no-extensions" },
-  { flag: "--no-pager" },
-  { flag: "--profile" },
-  { flag: "--help" }
-];
-var GLOBAL_FLAG_CONTRACTS = [
-  ...SUBCOMMAND_GLOBAL_FLAG_CONTRACTS,
-  { flag: "--version" }
-];
-var GOVERNANCE_AND_CONTENT_FILTER_FLAG_CONTRACTS = [
-  { flag: "--filter-reviewer-missing" },
-  { flag: "--filter-risk-missing" },
-  { flag: "--filter-confidence-missing" },
-  { flag: "--filter-sprint-missing" },
-  { flag: "--filter-release-missing" },
-  { flag: "--has-notes" },
-  { flag: "--no-notes" },
-  { flag: "--has-learnings" },
-  { flag: "--no-learnings" },
-  { flag: "--has-files" },
-  { flag: "--no-files" },
-  { flag: "--filter-files-missing" },
-  { flag: "--has-docs" },
-  { flag: "--no-docs" },
-  { flag: "--filter-docs-missing" },
-  { flag: "--has-tests" },
-  { flag: "--no-tests" },
-  { flag: "--has-comments" },
-  { flag: "--no-comments" },
-  { flag: "--has-deps" },
-  { flag: "--no-deps" },
-  { flag: "--has-body" },
-  { flag: "--empty-body" },
-  { flag: "--has-linked-command" },
-  { flag: "--no-linked-command" }
-];
-var MANY_GOVERNANCE_AND_CONTENT_FILTER_FLAG_CONTRACTS = [
-  { flag: "--filter-reviewer-missing" },
-  { flag: "--filter-risk-missing" },
-  { flag: "--filter-confidence-missing" },
-  { flag: "--filter-sprint-missing" },
-  { flag: "--filter-release-missing" },
-  { flag: "--filter-has-notes" },
-  { flag: "--filter-no-notes" },
-  { flag: "--filter-has-learnings" },
-  { flag: "--filter-no-learnings" },
-  { flag: "--filter-has-files" },
-  { flag: "--filter-no-files" },
-  { flag: "--filter-has-docs" },
-  { flag: "--filter-no-docs" },
-  { flag: "--filter-has-tests" },
-  { flag: "--filter-no-tests" },
-  { flag: "--filter-has-comments" },
-  { flag: "--filter-no-comments" },
-  { flag: "--filter-has-deps" },
-  { flag: "--filter-no-deps" },
-  { flag: "--filter-has-body" },
-  { flag: "--filter-empty-body" },
-  { flag: "--filter-has-linked-command" },
-  { flag: "--filter-no-linked-command" },
-  { flag: "--ids", list: true },
-  { flag: "--limit" },
-  { flag: "--offset" }
-];
-var LIST_FILTER_FLAG_CONTRACTS = [
-  { flag: "--status", list: true },
-  { flag: "--type" },
-  { flag: "--tag", aliases: ["--tags"] },
-  { flag: "--priority" },
-  { flag: "--deadline-before" },
-  { flag: "--deadline-after" },
-  { flag: "--updated-after" },
-  { flag: "--updated-before" },
-  { flag: "--created-after" },
-  { flag: "--created-before" },
-  { flag: "--ids", list: true },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--parent" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--filter-ac-missing" },
-  { flag: "--filter-estimates-missing", aliases: ["--filter-estimate-missing"] },
-  { flag: "--filter-resolution-missing" },
-  { flag: "--filter-metadata-missing" },
-  ...GOVERNANCE_AND_CONTENT_FILTER_FLAG_CONTRACTS,
-  { flag: "--limit" },
-  { flag: "--offset" },
-  { flag: "--no-truncate", aliases: ["--all"] },
-  { flag: "--compact" },
-  { flag: "--brief" },
-  { flag: "--full" },
-  { flag: "--fields", list: true },
-  { flag: "--sort" },
-  { flag: "--order" },
-  { flag: "--tree" },
-  { flag: "--tree-depth" },
-  { flag: "--tree_depth" },
-  { flag: "--include-body" },
-  { flag: "--format" },
-  { flag: "--stream" }
-];
-var AGGREGATE_FLAG_CONTRACTS = [
-  { flag: "--group-by", list: true },
-  { flag: "--count" },
-  { flag: "--completion" },
-  { flag: "--sum" },
-  { flag: "--avg" },
-  { flag: "--include-unparented" },
-  { flag: "--include_unparented" },
-  { flag: "--status" },
-  { flag: "--type" },
-  { flag: "--tag" },
-  { flag: "--priority" },
-  { flag: "--deadline-before" },
-  { flag: "--deadline-after" },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--parent" },
-  { flag: "--sprint" },
-  { flag: "--release" }
-];
-var DEDUPE_AUDIT_FLAG_CONTRACTS = [
-  { flag: "--mode" },
-  { flag: "--limit" },
-  { flag: "--threshold" },
-  { flag: "--status" },
-  { flag: "--type" },
-  { flag: "--tag" },
-  { flag: "--priority" },
-  { flag: "--deadline-before" },
-  { flag: "--deadline-after" },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--parent" },
-  { flag: "--sprint" },
-  { flag: "--release" }
-];
-var DEDUPE_MERGE_FLAG_CONTRACTS = [
-  { flag: "--keep" },
-  { flag: "--close", list: true },
-  { flag: "--apply" },
-  { flag: "--dry-run" },
-  { flag: "--skip-children" },
-  { flag: "--author" },
-  { flag: "--message" }
-];
-var COMMENTS_AUDIT_FLAG_CONTRACTS = [
-  { flag: "--status" },
-  { flag: "--type" },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--parent" },
-  { flag: "--tag" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--priority" },
-  { flag: "--limit-items" },
-  { flag: "--limit" },
-  { flag: "--full-history" },
-  { flag: "--latest" }
-];
-var COMMENTS_FLAG_CONTRACTS = [
-  { flag: "--add", aliases: ["--comment"] },
-  { flag: "--stdin" },
-  { flag: "--file" },
-  { flag: "--edit" },
-  { flag: "--delete" },
-  { flag: "--limit" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--allow-audit-comment" },
-  { flag: "--force" }
-];
-var NOTES_FLAG_CONTRACTS = [
-  { flag: "--add", aliases: ["--note"] },
-  { flag: "--limit" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--allow-audit-note" },
-  { flag: "--allow-audit-comment" },
-  { flag: "--force" }
-];
-var LEARNINGS_FLAG_CONTRACTS = [
-  { flag: "--add", aliases: ["--learning"] },
-  { flag: "--limit" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--allow-audit-learning" },
-  { flag: "--allow-audit-comment" },
-  { flag: "--force" }
-];
-var FILES_FLAG_CONTRACTS = [
-  { flag: "--add" },
-  { flag: "--add-glob" },
-  { flag: "--remove" },
-  { flag: "--migrate" },
-  // GH-170 (pm-pfnx): single-value note applied to every --add/--add-glob link
-  // in the invocation (embedded note= wins; usage error without an add).
-  { flag: "--note" },
-  { flag: "--list" },
-  { flag: "--append-stable" },
-  { flag: "--validate-paths" },
-  { flag: "--audit" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var DOCS_FLAG_CONTRACTS = [
-  { flag: "--add" },
-  { flag: "--add-glob" },
-  { flag: "--remove" },
-  { flag: "--migrate" },
-  // GH-170 (pm-pfnx): see FILES_FLAG_CONTRACTS --note.
-  { flag: "--note" },
-  { flag: "--list" },
-  { flag: "--validate-paths" },
-  { flag: "--audit" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var HISTORY_FLAG_CONTRACTS = [
-  { flag: "--limit" },
-  { flag: "--compact" },
-  { flag: "--full" },
-  { flag: "--diff" },
-  { flag: "--field" },
-  { flag: "--verify" },
-  { flag: "--format" }
-];
-var HISTORY_REDACT_FLAG_CONTRACTS = [
-  { flag: "--literal" },
-  { flag: "--regex" },
-  { flag: "--replacement" },
-  { flag: "--dry-run" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var HISTORY_REPAIR_FLAG_CONTRACTS = [
-  { flag: "--all" },
-  { flag: "--dry-run" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var HISTORY_COMPACT_FLAG_CONTRACTS = [
-  { flag: "--before" },
-  { flag: "--ids", list: true },
-  { flag: "--all-over", value_type: "number" },
-  { flag: "--closed" },
-  { flag: "--all-streams" },
-  { flag: "--min-entries", value_type: "number" },
-  { flag: "--dry-run" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var SCHEMA_FLAG_CONTRACTS = [
-  { flag: "--description" },
-  { flag: "--default-status", aliases: ["--default_status"] },
-  { flag: "--folder" },
-  { flag: "--alias" },
-  // --role is a repeatable Commander collect flag (NOT a comma-list contract),
-  // mirroring --alias; list:false keeps the bootstrap coalescer from corrupting
-  // values.
-  { flag: "--role" },
-  { flag: "--order" },
-  // add-field flags (custom runtime fields). --commands/--required-types are
-  // repeatable Commander collect flags (comma-splitting handled in the action),
-  // so they stay off the comma-list contract for the same reason as --alias.
-  { flag: "--type" },
-  { flag: "--commands" },
-  { flag: "--cli-flag" },
-  { flag: "--required" },
-  { flag: "--required-on-create" },
-  { flag: "--no-allow-unset" },
-  { flag: "--required-types" },
-  // add-type --infer flags (title-prefix type inference).
-  { flag: "--infer" },
-  { flag: "--min-count" },
-  { flag: "--apply" },
-  { flag: "--author" },
-  { flag: "--force" }
-];
-var PROFILE_FLAG_CONTRACTS = [
-  { flag: "--dry-run" },
-  { flag: "--author" },
-  { flag: "--force" }
-];
-var PLAN_FLAG_CONTRACTS = [
-  { flag: "--title" },
-  { flag: "--description" },
-  { flag: "--scope" },
-  { flag: "--parent" },
-  { flag: "--related" },
-  { flag: "--blocks" },
-  { flag: "--blocked-by", aliases: ["--blocked_by"] },
-  { flag: "--harness" },
-  { flag: "--mode" },
-  { flag: "--resume-context", aliases: ["--resume_context"] },
-  { flag: "--tags", aliases: ["--tag"], list: true },
-  { flag: "--priority" },
-  { flag: "--body" },
-  { flag: "--claim" },
-  { flag: "--from-search", aliases: ["--from_search"] },
-  { flag: "--template" },
-  { flag: "--step-title", aliases: ["--step_title"] },
-  // pm-6mit: --step is a Commander collect repeatable (ordered step titles on
-  // create; single-value stepTitle alias elsewhere). It must NOT be list:true —
-  // the bootstrap coalescer comma-joins list flags and would corrupt titles
-  // containing commas.
-  { flag: "--step" },
-  { flag: "--step-body", aliases: ["--step_body"] },
-  { flag: "--step-owner", aliases: ["--step_owner"] },
-  { flag: "--step-status", aliases: ["--step_status"] },
-  { flag: "--step-evidence", aliases: ["--step_evidence"] },
-  { flag: "--step-blocked-reason", aliases: ["--step_blocked_reason"] },
-  { flag: "--step-replacement", aliases: ["--step_replacement"] },
-  { flag: "--depends-on", aliases: ["--depends_on"] },
-  { flag: "--link" },
-  { flag: "--link-kind", aliases: ["--link_kind"] },
-  { flag: "--link-note", aliases: ["--link_note"] },
-  { flag: "--promote-to-item-dep", aliases: ["--promote_to_item_dep"] },
-  { flag: "--allow-multiple-active", aliases: ["--allow_multiple_active"] },
-  { flag: "--file" },
-  { flag: "--test" },
-  { flag: "--doc" },
-  { flag: "--decision-text", aliases: ["--decision_text", "--decision"] },
-  { flag: "--decision-rationale", aliases: ["--decision_rationale"] },
-  { flag: "--decision-evidence", aliases: ["--decision_evidence"] },
-  { flag: "--discovery-text", aliases: ["--discovery_text", "--discovery"] },
-  { flag: "--validation-text", aliases: ["--validation_text", "--validation"] },
-  { flag: "--validation-command", aliases: ["--validation_command"] },
-  { flag: "--validation-expected", aliases: ["--validation_expected"] },
-  { flag: "--depth" },
-  { flag: "--fields", list: true },
-  { flag: "--steps" },
-  { flag: "--materialize-type", aliases: ["--materialize_type"] },
-  { flag: "--materialize-parent", aliases: ["--materialize_parent"] },
-  { flag: "--materialize-tags", aliases: ["--materialize_tags"] },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var INIT_FLAG_CONTRACTS = [
-  { flag: "--preset" },
-  { flag: "--type-preset" },
-  { flag: "--defaults", short: "-y", aliases: ["--yes"] },
-  { flag: "--author" },
-  { flag: "--agent-guidance" },
-  { flag: "--with-packages" },
-  { flag: "--force" },
-  { flag: "--verbose" }
-];
-var CONFIG_FLAG_CONTRACTS = [
-  { flag: "--criterion" },
-  { flag: "--clear-criteria" },
-  { flag: "--format" },
-  { flag: "--policy" },
-  { flag: "--default-depth" },
-  { flag: "--activity-limit" },
-  { flag: "--stale-threshold-days" },
-  { flag: "--section-hierarchy" },
-  { flag: "--section-activity" },
-  { flag: "--section-progress" },
-  { flag: "--section-blockers" },
-  { flag: "--section-files" },
-  { flag: "--section-workload" },
-  { flag: "--section-staleness" },
-  { flag: "--section-tests" }
-];
-var EXTENSION_FLAG_CONTRACTS = [
-  { flag: "--init" },
-  { flag: "--scaffold" },
-  { flag: "--capability" },
-  { flag: "--install" },
-  { flag: "--uninstall" },
-  { flag: "--explore" },
-  { flag: "--list" },
-  { flag: "--manage" },
-  { flag: "--describe" },
-  { flag: "--markdown" },
-  { flag: "--output" },
-  { flag: "--reload" },
-  { flag: "--watch" },
-  { flag: "--doctor" },
-  { flag: "--catalog" },
-  { flag: "--adopt" },
-  { flag: "--adopt-all" },
-  { flag: "--activate" },
-  { flag: "--deactivate" },
-  { flag: "--project" },
-  { flag: "--local" },
-  { flag: "--global" },
-  { flag: "--gh" },
-  { flag: "--github" },
-  { flag: "--ref" },
-  { flag: "--detail" },
-  { flag: "--trace" },
-  { flag: "--runtime-probe" },
-  { flag: "--fix-managed-state" },
-  { flag: "--strict-exit" },
-  { flag: "--fail-on-warn" }
-];
-var EXTENSION_SCOPE_FLAG_CONTRACTS = [
-  { flag: "--project" },
-  { flag: "--local" },
-  { flag: "--global" }
-];
-var EXTENSION_INIT_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--capability" }
-];
-var PACKAGE_FLAG_CONTRACTS = [...EXTENSION_FLAG_CONTRACTS, { flag: "--declarative" }];
-var PACKAGE_INIT_FLAG_CONTRACTS = [...EXTENSION_INIT_FLAG_CONTRACTS, { flag: "--declarative" }];
-var EXTENSION_INSTALL_FLAG_CONTRACTS = [
-  { flag: "--project" },
-  { flag: "--local" },
-  { flag: "--global" },
-  { flag: "--gh" },
-  { flag: "--github" },
-  { flag: "--ref" }
-];
-var EXTENSION_UNINSTALL_FLAG_CONTRACTS = EXTENSION_SCOPE_FLAG_CONTRACTS;
-var EXTENSION_EXPLORE_FLAG_CONTRACTS = EXTENSION_SCOPE_FLAG_CONTRACTS;
-var EXTENSION_DESCRIBE_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--markdown" },
-  { flag: "--output" }
-];
-var EXTENSION_ADOPT_ALL_FLAG_CONTRACTS = EXTENSION_SCOPE_FLAG_CONTRACTS;
-var EXTENSION_ACTIVATE_FLAG_CONTRACTS = EXTENSION_SCOPE_FLAG_CONTRACTS;
-var EXTENSION_DEACTIVATE_FLAG_CONTRACTS = EXTENSION_SCOPE_FLAG_CONTRACTS;
-var EXTENSION_MANAGE_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--runtime-probe" },
-  { flag: "--fix-managed-state" }
-];
-var EXTENSION_RELOAD_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--watch" }
-];
-var EXTENSION_DOCTOR_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--detail" },
-  { flag: "--trace" },
-  { flag: "--fix-managed-state" },
-  { flag: "--strict-exit" },
-  { flag: "--fail-on-warn" }
-];
-var EXTENSION_CATALOG_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--fields", list: true }
-];
-var EXTENSION_ADOPT_FLAG_CONTRACTS = [
-  ...EXTENSION_SCOPE_FLAG_CONTRACTS,
-  { flag: "--gh" },
-  { flag: "--github" },
-  { flag: "--ref" }
-];
-var INSTALL_FLAG_CONTRACTS = [
-  { flag: "--project" },
-  { flag: "--local" },
-  { flag: "--global" },
-  { flag: "--gh" },
-  { flag: "--github" },
-  { flag: "--ref" }
-];
-var UPGRADE_FLAG_CONTRACTS = [
-  { flag: "--dry-run" },
-  { flag: "--cli-only" },
-  { flag: "--packages-only" },
-  { flag: "--project" },
-  { flag: "--local" },
-  { flag: "--global" },
-  { flag: "--repair" },
-  { flag: "--tag" },
-  { flag: "--package-name" }
-];
-var REINDEX_FLAG_CONTRACTS = [
-  { flag: "--mode" },
-  { flag: "--progress" }
-];
-var CLOSE_FLAG_CONTRACTS = [
-  { flag: "--reason" },
-  { flag: "--close-reason" },
-  { flag: "--duplicate-of" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--validate-close" },
-  // pm-fl0c #11 (2026-05-28) + Codex P2 follow-up: inline closure-validation
-  // fields. Surface them through the contract so `pm contracts --command
-  // close`, the JSON help payload, and bootstrap flag normalization /
-  // suggestions all stay consistent with the commander registration.
-  { flag: "--resolution" },
-  { flag: "--expected-result", aliases: ["--expected_result", "--expected"] },
-  { flag: "--actual-result", aliases: ["--actual_result", "--actual"] },
-  { flag: "--force" }
-];
-var CLOSE_MANY_FLAG_CONTRACTS = [
-  { flag: "--filter-status", list: true },
-  { flag: "--filter-type" },
-  { flag: "--filter-tag" },
-  { flag: "--filter-priority" },
-  { flag: "--filter-deadline-before" },
-  { flag: "--filter-deadline-after" },
-  { flag: "--filter-updated-after" },
-  { flag: "--filter-updated-before" },
-  { flag: "--filter-created-after" },
-  { flag: "--filter-created-before" },
-  { flag: "--filter-assignee" },
-  { flag: "--filter-assignee-filter" },
-  { flag: "--filter-assignee_filter" },
-  { flag: "--filter-parent" },
-  { flag: "--filter-sprint" },
-  { flag: "--filter-release" },
-  ...MANY_GOVERNANCE_AND_CONTENT_FILTER_FLAG_CONTRACTS,
-  { flag: "--reason" },
-  { flag: "--resolution" },
-  { flag: "--expected-result", aliases: ["--expected_result", "--expected"] },
-  { flag: "--actual-result", aliases: ["--actual_result", "--actual"] },
-  { flag: "--validate-close" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" },
-  { flag: "--dry-run" },
-  { flag: "--rollback" },
-  { flag: "--no-checkpoint" }
-];
-var APPEND_FLAG_CONTRACTS = [
-  { flag: "--body", short: "-b" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var CLAIM_FLAG_CONTRACTS = [
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var RESTORE_FLAG_CONTRACTS = [
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var DELETE_FLAG_CONTRACTS = [
-  { flag: "--dry-run" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var RELEASE_FLAG_CONTRACTS = [
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--allow-audit-release" },
-  { flag: "--force" }
-];
-var START_TASK_FLAG_CONTRACTS = [
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var PAUSE_TASK_FLAG_CONTRACTS = [
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var CLOSE_TASK_FLAG_CONTRACTS = [
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--validate-close" },
-  { flag: "--force" }
-];
-var SCHEDULING_SHORTCUT_COMMON_FLAG_CONTRACTS = [
-  { flag: "--parent" },
-  { flag: "--allow-missing-parent" },
-  { flag: "--tags" },
-  { flag: "--priority" },
-  { flag: "--body" },
-  { flag: "--description" },
-  { flag: "--author" },
-  { flag: "--message" }
-];
-var MEET_FLAG_CONTRACTS = [
-  { flag: "--start" },
-  { flag: "--duration" },
-  { flag: "--end" },
-  { flag: "--location" },
-  { flag: "--timezone" },
-  { flag: "--all-day" },
-  ...SCHEDULING_SHORTCUT_COMMON_FLAG_CONTRACTS
-];
-var EVENT_FLAG_CONTRACTS = MEET_FLAG_CONTRACTS;
-var REMIND_FLAG_CONTRACTS = [
-  { flag: "--at" },
-  { flag: "--text" },
-  ...SCHEDULING_SHORTCUT_COMMON_FLAG_CONTRACTS
-];
-var TEST_FLAG_CONTRACTS = [
-  { flag: "--add" },
-  { flag: "--add-json" },
-  { flag: "--remove" },
-  { flag: "--run" },
-  { flag: "--match" },
-  { flag: "--only-index" },
-  { flag: "--only-last" },
-  { flag: "--background" },
-  { flag: "--timeout" },
-  { flag: "--progress" },
-  { flag: "--env-set" },
-  { flag: "--env-clear" },
-  { flag: "--shared-host-safe" },
-  { flag: "--pm-context" },
-  { flag: "--override-linked-pm-context" },
-  { flag: "--fail-on-context-mismatch" },
-  { flag: "--fail-on-skipped" },
-  { flag: "--fail-on-empty-test-run" },
-  { flag: "--require-assertions-for-pm" },
-  { flag: "--check-context" },
-  { flag: "--auto-pm-context" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var TEST_ALL_FLAG_CONTRACTS = [
-  { flag: "--status" },
-  { flag: "--limit" },
-  { flag: "--offset" },
-  { flag: "--background" },
-  { flag: "--timeout" },
-  { flag: "--progress" },
-  { flag: "--env-set" },
-  { flag: "--env-clear" },
-  { flag: "--shared-host-safe" },
-  { flag: "--pm-context" },
-  { flag: "--override-linked-pm-context" },
-  { flag: "--fail-on-context-mismatch" },
-  { flag: "--fail-on-skipped" },
-  { flag: "--fail-on-empty-test-run" },
-  { flag: "--require-assertions-for-pm" },
-  { flag: "--check-context" },
-  { flag: "--auto-pm-context" }
-];
-var TELEMETRY_FLAG_CONTRACTS = [
-  { flag: "--limit" }
-];
-var TEST_RUNS_FLAG_CONTRACTS = [
-  { flag: "--status" },
-  { flag: "--limit" },
-  { flag: "--stream" },
-  { flag: "--tail" },
-  { flag: "--force" },
-  { flag: "--author" }
-];
-var GC_FLAG_CONTRACTS = [
-  { flag: "--dry-run" },
-  { flag: "--scope" }
-];
-var STATS_FLAG_CONTRACTS = [
-  { flag: "--storage" },
-  { flag: "--metadata-coverage" },
-  { flag: "--field-utilization" },
-  { flag: "--by-assignee" },
-  { flag: "--by-tag" },
-  { flag: "--by-priority" },
-  { flag: "--tag-prefix" }
-];
-var HEALTH_FLAG_CONTRACTS = [
-  { flag: "--strict-directories" },
-  { flag: "--strict-exit" },
-  { flag: "--fail-on-warn" },
-  { flag: "--check-only" },
-  { flag: "--check-telemetry" },
-  { flag: "--no-refresh" },
-  { flag: "--refresh-vectors" },
-  { flag: "--verbose-stale-items" },
-  { flag: "--brief" },
-  { flag: "--summary" },
-  { flag: "--skip-vectors" },
-  { flag: "--skip-integrity" },
-  { flag: "--skip-drift" },
-  { flag: "--full" }
-];
-var VALIDATE_FLAG_CONTRACTS = [
-  { flag: "--check-metadata" },
-  { flag: "--metadata-profile" },
-  { flag: "--check-resolution" },
-  { flag: "--check-lifecycle" },
-  { flag: "--check-stale-blockers" },
-  { flag: "--dependency-cycle-severity" },
-  { flag: "--parent-cycle-severity" },
-  { flag: "--check-files" },
-  { flag: "--scan-mode" },
-  { flag: "--include-pm-internals" },
-  { flag: "--verbose-file-lists" },
-  { flag: "--verbose-diagnostics" },
-  { flag: "--all-affected-ids" },
-  { flag: "--strict-exit" },
-  { flag: "--fail-on-warn" },
-  { flag: "--fix-hints" },
-  { flag: "--auto-fix" },
-  { flag: "--dry-run" },
-  // NOT list:true — repeatable via Commander's collector; the bootstrap
-  // coalescer must not comma-join occurrences (values may also be
-  // comma-separated lists which the resolver splits itself).
-  { flag: "--fix-scope" },
-  { flag: "--prune-missing" },
-  { flag: "--check-history-drift" },
-  { flag: "--check-command-references" }
-];
-var CREATE_FLAG_CONTRACTS = [
-  { short: "-t", flag: "--title" },
-  { flag: "--id" },
-  { short: "-d", flag: "--description" },
-  { flag: "--type" },
-  { flag: "--template" },
-  { flag: "--create-mode" },
-  { flag: "--create_mode" },
-  { flag: "--schedule-preset" },
-  { flag: "--schedule_preset" },
-  { short: "-s", flag: "--status" },
-  { short: "-p", flag: "--priority" },
-  { flag: "--tags", aliases: ["--tag"], list: true },
-  // NOT list:true — these use Commander's repeatable collector. Marking them
-  // list:true would make the bootstrap coalescer comma-join repeated
-  // occurrences (`--add-tags '["a","b"]' --add-tags c` -> `["a","b"],c`),
-  // corrupting the JSON-array value form before parseTags sees it.
-  { flag: "--add-tags", aliases: ["--add_tags"] },
-  { short: "-b", flag: "--body" },
-  { flag: "--body-file" },
-  { flag: "--deadline" },
-  { flag: "--estimate" },
-  { flag: "--estimated-minutes" },
-  { flag: "--estimated_minutes" },
-  { flag: "--acceptance-criteria" },
-  { flag: "--acceptance_criteria" },
-  { flag: "--ac" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--assignee" },
-  { flag: "--parent" },
-  { flag: "--allow-missing-parent" },
-  { flag: "--reviewer" },
-  { flag: "--risk" },
-  { flag: "--confidence" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--blocked-by" },
-  { flag: "--blocked-reason" },
-  { flag: "--unblock-note" },
-  { flag: "--reporter" },
-  { flag: "--severity" },
-  { flag: "--environment" },
-  { flag: "--repro-steps" },
-  { flag: "--resolution" },
-  { flag: "--expected-result" },
-  { flag: "--actual-result" },
-  { flag: "--affected-version" },
-  { flag: "--fixed-version" },
-  { flag: "--component" },
-  { flag: "--regression" },
-  { flag: "--customer-impact" },
-  { flag: "--customer_impact" },
-  { flag: "--definition-of-ready" },
-  { flag: "--definition_of_ready" },
-  { flag: "--order" },
-  { flag: "--rank" },
-  { flag: "--goal" },
-  { flag: "--objective" },
-  { flag: "--value" },
-  { flag: "--impact" },
-  { flag: "--outcome" },
-  { flag: "--why-now" },
-  { flag: "--why_now" },
-  { flag: "--blocked_by" },
-  { flag: "--blocked_reason" },
-  { flag: "--unblock_note" },
-  { flag: "--repro_steps" },
-  { flag: "--expected_result" },
-  { flag: "--actual_result" },
-  { flag: "--expected" },
-  { flag: "--actual" },
-  { flag: "--affected_version" },
-  { flag: "--fixed_version" },
-  { flag: "--dep" },
-  { flag: "--type-option" },
-  { flag: "--type_option" },
-  { flag: "--field" },
-  { flag: "--reminder" },
-  { flag: "--event" },
-  { flag: "--comment" },
-  { flag: "--note" },
-  { flag: "--learning" },
-  { flag: "--file" },
-  { flag: "--test" },
-  { flag: "--doc" },
-  { flag: "--unset" },
-  { flag: "--clear-deps" },
-  { flag: "--clear-comments" },
-  { flag: "--clear-notes" },
-  { flag: "--clear-learnings" },
-  { flag: "--clear-files" },
-  { flag: "--clear-tests" },
-  { flag: "--clear-docs" },
-  { flag: "--clear-reminders" },
-  { flag: "--clear-events" },
-  { flag: "--clear-type-options" }
-];
-var COPY_FLAG_CONTRACTS = [
-  { flag: "--title" },
-  { flag: "--author" },
-  { flag: "--message" }
-];
-var FOCUS_FLAG_CONTRACTS = [
-  { flag: "--clear" }
-];
-var UPDATE_FLAG_CONTRACTS = [
-  { short: "-t", flag: "--title" },
-  { short: "-d", flag: "--description" },
-  { short: "-b", flag: "--body" },
-  { flag: "--body-file" },
-  { short: "-s", flag: "--status" },
-  { flag: "--close-reason" },
-  { flag: "--close_reason" },
-  { short: "-p", flag: "--priority" },
-  { flag: "--type" },
-  { flag: "--tags", aliases: ["--tag"], list: true },
-  // NOT list:true — Commander's repeatable collector accumulates these, so
-  // bootstrap coalescing must not comma-join repeated occurrences (it would
-  // corrupt JSON-array values like `--add-tags '["a","b"]' --add-tags c`).
-  { flag: "--add-tags", aliases: ["--add_tags"] },
-  { flag: "--remove-tags", aliases: ["--remove_tags"] },
-  { flag: "--deadline" },
-  { flag: "--estimate" },
-  { flag: "--estimated-minutes" },
-  { flag: "--estimated_minutes" },
-  { flag: "--acceptance-criteria" },
-  { flag: "--acceptance_criteria" },
-  { flag: "--ac" },
-  { flag: "--assignee" },
-  { flag: "--parent" },
-  { flag: "--reviewer" },
-  { flag: "--risk" },
-  { flag: "--confidence" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--blocked-by" },
-  { flag: "--blocked-reason" },
-  { flag: "--unblock-note" },
-  { flag: "--reporter" },
-  { flag: "--severity" },
-  { flag: "--environment" },
-  { flag: "--repro-steps" },
-  { flag: "--resolution" },
-  { flag: "--expected-result" },
-  { flag: "--actual-result" },
-  { flag: "--affected-version" },
-  { flag: "--fixed-version" },
-  { flag: "--fixed_version" },
-  { flag: "--component" },
-  { flag: "--regression" },
-  { flag: "--customer-impact" },
-  { flag: "--customer_impact" },
-  { flag: "--definition-of-ready" },
-  { flag: "--definition_of_ready" },
-  { flag: "--order" },
-  { flag: "--rank" },
-  { flag: "--goal" },
-  { flag: "--objective" },
-  { flag: "--value" },
-  { flag: "--impact" },
-  { flag: "--outcome" },
-  { flag: "--why-now" },
-  { flag: "--why_now" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--blocked_by" },
-  { flag: "--blocked_reason" },
-  { flag: "--unblock_note" },
-  { flag: "--repro_steps" },
-  { flag: "--expected_result" },
-  { flag: "--actual_result" },
-  { flag: "--expected" },
-  { flag: "--actual" },
-  { flag: "--affected_version" },
-  { flag: "--dep" },
-  { flag: "--dep-remove" },
-  { flag: "--dep_remove" },
-  { flag: "--replace-deps" },
-  { flag: "--replace-tests" },
-  { flag: "--comment" },
-  { flag: "--note" },
-  { flag: "--learning" },
-  { flag: "--file" },
-  { flag: "--test" },
-  { flag: "--doc" },
-  { flag: "--reminder" },
-  { flag: "--event" },
-  { flag: "--type-option" },
-  { flag: "--type_option" },
-  { flag: "--field" },
-  { flag: "--unset" },
-  { flag: "--clear-deps" },
-  { flag: "--clear-comments" },
-  { flag: "--clear-notes" },
-  { flag: "--clear-learnings" },
-  { flag: "--clear-files" },
-  { flag: "--clear-tests" },
-  { flag: "--clear-docs" },
-  { flag: "--clear-reminders" },
-  { flag: "--clear-events" },
-  { flag: "--clear-type-options" },
-  { flag: "--allow-audit-update" },
-  { flag: "--allow_audit_update" },
-  { flag: "--allow-audit-dep-update" },
-  { flag: "--allow_audit_dep_update" },
-  { flag: "--force" }
-];
-var UPDATE_MANY_FLAG_CONTRACTS = [
-  { flag: "--filter-status" },
-  { flag: "--filter-type" },
-  { flag: "--filter-tag" },
-  { flag: "--filter-priority" },
-  { flag: "--filter-deadline-before" },
-  { flag: "--filter-deadline-after" },
-  { flag: "--filter-updated-after" },
-  { flag: "--filter-updated-before" },
-  { flag: "--filter-created-after" },
-  { flag: "--filter-created-before" },
-  { flag: "--filter-assignee" },
-  { flag: "--filter-assignee-filter" },
-  { flag: "--filter-assignee_filter" },
-  { flag: "--filter-parent" },
-  { flag: "--filter-sprint" },
-  { flag: "--filter-release" },
-  { flag: "--filter-ac-missing" },
-  { flag: "--filter-estimates-missing", aliases: ["--filter-estimate-missing"] },
-  { flag: "--filter-resolution-missing" },
-  { flag: "--filter-metadata-missing" },
-  ...MANY_GOVERNANCE_AND_CONTENT_FILTER_FLAG_CONTRACTS,
-  { flag: "--dry-run" },
-  { flag: "--rollback" },
-  { flag: "--no-checkpoint" },
-  { short: "-t", flag: "--title" },
-  { short: "-d", flag: "--description" },
-  { short: "-b", flag: "--body" },
-  { short: "-p", flag: "--priority" },
-  { flag: "--type" },
-  { flag: "--tags", aliases: ["--tag"], list: true },
-  // NOT list:true — Commander's repeatable collector accumulates these, so
-  // bootstrap coalescing must not comma-join repeated occurrences (it would
-  // corrupt JSON-array values like `--add-tags '["a","b"]' --add-tags c`).
-  { flag: "--add-tags", aliases: ["--add_tags"] },
-  { flag: "--remove-tags", aliases: ["--remove_tags"] },
-  { flag: "--deadline" },
-  { flag: "--estimate" },
-  { flag: "--estimated-minutes" },
-  { flag: "--estimated_minutes" },
-  { flag: "--acceptance-criteria" },
-  { flag: "--acceptance_criteria" },
-  { flag: "--ac" },
-  { flag: "--definition-of-ready" },
-  { flag: "--definition_of_ready" },
-  { flag: "--order" },
-  { flag: "--rank" },
-  { flag: "--goal" },
-  { flag: "--objective" },
-  { flag: "--value" },
-  { flag: "--impact" },
-  { flag: "--outcome" },
-  { flag: "--why-now" },
-  { flag: "--why_now" },
-  { flag: "--reviewer" },
-  { flag: "--risk" },
-  { flag: "--confidence" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--reporter" },
-  { flag: "--severity" },
-  { flag: "--environment" },
-  { flag: "--repro-steps" },
-  { flag: "--repro_steps" },
-  { flag: "--resolution" },
-  { flag: "--expected-result" },
-  { flag: "--expected_result" },
-  { flag: "--expected" },
-  { flag: "--actual-result" },
-  { flag: "--actual_result" },
-  { flag: "--actual" },
-  { flag: "--affected-version" },
-  { flag: "--affected_version" },
-  { flag: "--fixed-version" },
-  { flag: "--fixed_version" },
-  { flag: "--component" },
-  { flag: "--regression" },
-  { flag: "--customer-impact" },
-  { flag: "--customer_impact" },
-  { flag: "--dep" },
-  { flag: "--dep-remove" },
-  { flag: "--dep_remove" },
-  { flag: "--replace-deps" },
-  { flag: "--replace-tests" },
-  { flag: "--comment" },
-  { flag: "--note" },
-  { flag: "--learning" },
-  { flag: "--file" },
-  { flag: "--test" },
-  { flag: "--doc" },
-  { flag: "--reminder" },
-  { flag: "--event" },
-  { flag: "--type-option" },
-  { flag: "--type_option" },
-  { flag: "--unset" },
-  { flag: "--clear-deps" },
-  { flag: "--clear-comments" },
-  { flag: "--clear-notes" },
-  { flag: "--clear-learnings" },
-  { flag: "--clear-files" },
-  { flag: "--clear-tests" },
-  { flag: "--clear-docs" },
-  { flag: "--clear-reminders" },
-  { flag: "--clear-events" },
-  { flag: "--clear-type-options" },
-  { flag: "--allow-audit-update" },
-  { flag: "--allow_audit_update" },
-  { flag: "--allow-audit-dep-update" },
-  { flag: "--allow_audit_dep_update" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--force" }
-];
-var NORMALIZE_FLAG_CONTRACTS = [
-  { flag: "--filter-status" },
-  { flag: "--filter-type" },
-  { flag: "--filter-tag" },
-  { flag: "--filter-priority" },
-  { flag: "--filter-deadline-before" },
-  { flag: "--filter-deadline-after" },
-  { flag: "--filter-assignee" },
-  { flag: "--filter-assignee-filter" },
-  { flag: "--filter-assignee_filter" },
-  { flag: "--filter-parent" },
-  { flag: "--filter-sprint" },
-  { flag: "--filter-release" },
-  { flag: "--limit" },
-  { flag: "--offset" },
-  { flag: "--dry-run" },
-  { flag: "--apply" },
-  { flag: "--author" },
-  { flag: "--message" },
-  { flag: "--allow-audit-update" },
-  { flag: "--allow_audit_update" },
-  { flag: "--force" }
-];
-var CALENDAR_FLAG_CONTRACTS = [
-  { flag: "--view" },
-  { flag: "--date" },
-  { flag: "--from" },
-  { flag: "--to" },
-  { flag: "--past" },
-  { flag: "--full-period" },
-  { flag: "--full_period" },
-  { flag: "--type" },
-  { flag: "--tag" },
-  { flag: "--priority" },
-  { flag: "--status" },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--include" },
-  { flag: "--recurrence-lookahead-days" },
-  { flag: "--recurrence-lookback-days" },
-  { flag: "--occurrence-limit" },
-  { flag: "--limit" },
-  { flag: "--format" }
-];
-var ACTIVITY_FLAG_CONTRACTS = [
-  { flag: "--id" },
-  { flag: "--op" },
-  { flag: "--author" },
-  { flag: "--from" },
-  { flag: "--to" },
-  { flag: "--limit" },
-  { flag: "--compact" },
-  { flag: "--full" },
-  { flag: "--stream" }
-];
-var CONTEXT_FLAG_CONTRACTS = [
-  { flag: "--date" },
-  { flag: "--from" },
-  { flag: "--to" },
-  { flag: "--past" },
-  { flag: "--type" },
-  { flag: "--tag" },
-  { flag: "--priority" },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--parent" },
-  { flag: "--limit" },
-  { flag: "--format" },
-  { flag: "--depth" },
-  { flag: "--fields", list: true },
-  { flag: "--section" },
-  { flag: "--activity-limit" },
-  { flag: "--stale-threshold" }
-];
-var GET_FLAG_CONTRACTS = [
-  { flag: "--depth" },
-  { flag: "--full" },
-  { flag: "--fields", list: true },
-  { flag: "--tree" },
-  { flag: "--tree-depth" },
-  { flag: "--tree_depth" },
-  { flag: "--format" }
-];
-var GUIDE_FLAG_CONTRACTS = [
-  { flag: "--list" },
-  { flag: "--format" },
-  { flag: "--depth" }
-];
-var DEPS_FLAG_CONTRACTS = [
-  { flag: "--format" },
-  { flag: "--max-depth" },
-  { flag: "--collapse" },
-  { flag: "--summary" }
-];
-var EVAL_FLAG_CONTRACTS = [
-  { flag: "--mode" },
-  { flag: "--k" },
-  { flag: "--fail-under" },
-  { flag: "--queries" },
-  { flag: "--format" }
-];
-var NEXT_FLAG_CONTRACTS = [
-  { flag: "--type" },
-  { flag: "--tag" },
-  { flag: "--priority" },
-  { flag: "--assignee" },
-  { flag: "--assignee-filter" },
-  { flag: "--assignee_filter" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--parent" },
-  { flag: "--limit" },
-  { flag: "--blocked-limit" },
-  { flag: "--blocked_limit" },
-  { flag: "--ready-only" },
-  { flag: "--ready_only" },
-  { flag: "--format" }
-];
-var SEARCH_FLAG_CONTRACTS = [
-  { flag: "--mode" },
-  { flag: "--semantic" },
-  { flag: "--hybrid" },
-  { flag: "--match-mode" },
-  { flag: "--min-score" },
-  { flag: "--count" },
-  { flag: "--semantic-weight" },
-  { flag: "--include-linked" },
-  { flag: "--title-exact" },
-  { flag: "--phrase-exact" },
-  { flag: "--highlight" },
-  { flag: "--compact" },
-  { flag: "--full" },
-  { flag: "--fields", list: true },
-  { flag: "--format" },
-  { flag: "--limit" },
-  { flag: "--status", list: true },
-  { flag: "--type" },
-  { flag: "--tag", aliases: ["--tags"] },
-  { flag: "--priority" },
-  { flag: "--deadline-before" },
-  { flag: "--deadline-after" },
-  { flag: "--updated-after" },
-  { flag: "--updated-before" },
-  { flag: "--created-after" },
-  { flag: "--created-before" },
-  { flag: "--assignee" },
-  { flag: "--sprint" },
-  { flag: "--release" },
-  { flag: "--parent" },
-  ...GOVERNANCE_AND_CONTENT_FILTER_FLAG_CONTRACTS
-];
-var CONTRACTS_FLAG_CONTRACTS = [
-  { flag: "--action" },
-  { flag: "--command" },
-  { flag: "--schema-only" },
-  { flag: "--flags-only" },
-  { flag: "--availability-only" },
-  { flag: "--runtime-only" },
-  { flag: "--active-only" },
-  { flag: "--full" }
-];
-var COMPLETION_FLAG_CONTRACTS = [
-  { flag: "--eager-tags" }
-];
-function toUniqueFlagContracts(contracts) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const contract of contracts) {
-    const aliasKey = (contract.aliases ?? []).join(",");
-    const key = `${contract.flag}|${contract.short ?? ""}|${aliasKey}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    unique.push(contract);
-  }
-  return unique;
-}
-function withSubcommandGlobalFlags(contracts) {
-  return withFlagAliasMetadata(toUniqueFlagContracts([...SUBCOMMAND_GLOBAL_FLAG_CONTRACTS, ...contracts]));
-}
-var LIST_COMMAND_FLAG_ALIASES = [
-  "list",
-  "list-all",
-  "list-draft",
-  "list-open",
-  "list-in-progress",
-  "list-blocked",
-  "list-closed",
-  "list-canceled"
-];
-var SUBCOMMAND_FLAG_CONTRACTS_BY_COMMAND = new Map([
-  ...LIST_COMMAND_FLAG_ALIASES.map((command) => [command, LIST_FILTER_FLAG_CONTRACTS]),
-  ["templates", CREATE_FLAG_CONTRACTS],
-  ["cal", CALENDAR_FLAG_CONTRACTS],
-  ["ctx", CONTEXT_FLAG_CONTRACTS],
-  ["test-runs-worker", TEST_RUNS_FLAG_CONTRACTS],
-  ["init", INIT_FLAG_CONTRACTS],
-  ["config", CONFIG_FLAG_CONTRACTS],
-  ["extension", EXTENSION_FLAG_CONTRACTS],
-  // `--declarative` is package-only (see PACKAGE_FLAG_CONTRACTS).
-  ["package", PACKAGE_FLAG_CONTRACTS],
-  ["packages", PACKAGE_FLAG_CONTRACTS],
-  ["install", INSTALL_FLAG_CONTRACTS],
-  ["upgrade", UPGRADE_FLAG_CONTRACTS],
-  ["create", CREATE_FLAG_CONTRACTS],
-  ["copy", COPY_FLAG_CONTRACTS],
-  ["focus", FOCUS_FLAG_CONTRACTS],
-  ["aggregate", AGGREGATE_FLAG_CONTRACTS],
-  ["dedupe-audit", DEDUPE_AUDIT_FLAG_CONTRACTS],
-  ["dedupe-merge", DEDUPE_MERGE_FLAG_CONTRACTS],
-  ["normalize", NORMALIZE_FLAG_CONTRACTS],
-  ["calendar", CALENDAR_FLAG_CONTRACTS],
-  ["context", CONTEXT_FLAG_CONTRACTS],
-  ["get", GET_FLAG_CONTRACTS],
-  ["guide", GUIDE_FLAG_CONTRACTS],
-  ["search", SEARCH_FLAG_CONTRACTS],
-  ["next", NEXT_FLAG_CONTRACTS],
-  ["eval", EVAL_FLAG_CONTRACTS],
-  ["history", HISTORY_FLAG_CONTRACTS],
-  ["history-redact", HISTORY_REDACT_FLAG_CONTRACTS],
-  ["history-repair", HISTORY_REPAIR_FLAG_CONTRACTS],
-  ["history-compact", HISTORY_COMPACT_FLAG_CONTRACTS],
-  ["schema", SCHEMA_FLAG_CONTRACTS],
-  ["profile", PROFILE_FLAG_CONTRACTS],
-  ["plan", PLAN_FLAG_CONTRACTS],
-  ["activity", ACTIVITY_FLAG_CONTRACTS],
-  ["restore", RESTORE_FLAG_CONTRACTS],
-  ["update", UPDATE_FLAG_CONTRACTS],
-  ["update-many", UPDATE_MANY_FLAG_CONTRACTS],
-  ["close", CLOSE_FLAG_CONTRACTS],
-  ["close-many", CLOSE_MANY_FLAG_CONTRACTS],
-  ["delete", DELETE_FLAG_CONTRACTS],
-  ["append", APPEND_FLAG_CONTRACTS],
-  ["comments", COMMENTS_FLAG_CONTRACTS],
-  ["comments-audit", COMMENTS_AUDIT_FLAG_CONTRACTS],
-  ["notes", NOTES_FLAG_CONTRACTS],
-  ["learnings", LEARNINGS_FLAG_CONTRACTS],
-  ["files", FILES_FLAG_CONTRACTS],
-  ["docs", DOCS_FLAG_CONTRACTS],
-  ["deps", DEPS_FLAG_CONTRACTS],
-  ["test", TEST_FLAG_CONTRACTS],
-  ["test-all", TEST_ALL_FLAG_CONTRACTS],
-  ["telemetry", TELEMETRY_FLAG_CONTRACTS],
-  ["health", HEALTH_FLAG_CONTRACTS],
-  ["validate", VALIDATE_FLAG_CONTRACTS],
-  ["gc", GC_FLAG_CONTRACTS],
-  ["stats", STATS_FLAG_CONTRACTS],
-  ["contracts", CONTRACTS_FLAG_CONTRACTS],
-  ["completion", COMPLETION_FLAG_CONTRACTS],
-  ["claim", CLAIM_FLAG_CONTRACTS],
-  ["release", RELEASE_FLAG_CONTRACTS],
-  ["start-task", START_TASK_FLAG_CONTRACTS],
-  ["pause-task", PAUSE_TASK_FLAG_CONTRACTS],
-  ["close-task", CLOSE_TASK_FLAG_CONTRACTS],
-  ["meet", MEET_FLAG_CONTRACTS],
-  ["event", EVENT_FLAG_CONTRACTS],
-  ["remind", REMIND_FLAG_CONTRACTS]
-]);
-var EXTENSION_LIFECYCLE_FLAG_CONTRACTS_BY_SUBCOMMAND = /* @__PURE__ */ new Map([
-  ["install", EXTENSION_INSTALL_FLAG_CONTRACTS],
-  ["uninstall", EXTENSION_UNINSTALL_FLAG_CONTRACTS],
-  ["explore", EXTENSION_EXPLORE_FLAG_CONTRACTS],
-  ["manage", EXTENSION_MANAGE_FLAG_CONTRACTS],
-  ["describe", EXTENSION_DESCRIBE_FLAG_CONTRACTS],
-  ["reload", EXTENSION_RELOAD_FLAG_CONTRACTS],
-  ["doctor", EXTENSION_DOCTOR_FLAG_CONTRACTS],
-  ["catalog", EXTENSION_CATALOG_FLAG_CONTRACTS],
-  ["adopt", EXTENSION_ADOPT_FLAG_CONTRACTS],
-  ["adopt-all", EXTENSION_ADOPT_ALL_FLAG_CONTRACTS],
-  ["activate", EXTENSION_ACTIVATE_FLAG_CONTRACTS],
-  ["deactivate", EXTENSION_DEACTIVATE_FLAG_CONTRACTS]
-]);
-function normalizeCommandNameForContracts(commandName) {
-  if (typeof commandName !== "string") {
-    return "";
-  }
-  return commandName.trim().toLowerCase();
-}
-function resolveExtensionLifecycleFlagContracts(rootCommand, lifecycleSubcommand) {
-  if (lifecycleSubcommand === "init") {
-    return rootCommand === "extension" ? EXTENSION_INIT_FLAG_CONTRACTS : PACKAGE_INIT_FLAG_CONTRACTS;
-  }
-  return EXTENSION_LIFECYCLE_FLAG_CONTRACTS_BY_SUBCOMMAND.get(lifecycleSubcommand) ?? [];
-}
-function resolveSubcommandFlagContractsForCommand(commandName) {
-  const normalized = normalizeCommandNameForContracts(commandName);
-  if (normalized.length === 0) {
-    return withSubcommandGlobalFlags([]);
-  }
-  const [rootCommand, lifecycleSubcommand, ...extraParts] = normalized.split(/\s+/);
-  if ((rootCommand === "extension" || rootCommand === "package" || rootCommand === "packages") && lifecycleSubcommand !== void 0 && extraParts.length === 0) {
-    return withSubcommandGlobalFlags(resolveExtensionLifecycleFlagContracts(rootCommand, lifecycleSubcommand));
-  }
-  return withSubcommandGlobalFlags(SUBCOMMAND_FLAG_CONTRACTS_BY_COMMAND.get(normalized) ?? []);
-}
-function toCompletionFlagString(flagContracts, includeGlobal = true) {
-  const aliasAwareContracts = withFlagAliasMetadata(flagContracts);
-  const scoped = aliasAwareContracts.flatMap((entry) => [entry.short, entry.flag, ...entry.aliases ?? []]).filter((value) => Boolean(value));
-  const all = includeGlobal ? [
-    ...scoped,
-    ...SUBCOMMAND_GLOBAL_FLAG_CONTRACTS.flatMap((entry) => [entry.short, entry.flag, ...entry.aliases ?? []]).filter((value) => Boolean(value))
-  ] : scoped;
-  return normalizeUniqueStringList(all).join(" ");
-}
-
-// dist/sdk/cli-contracts/tool-parameter-tables.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] = "75c2e15d-069f-562a-8309-ceaa9ffcde14");
-  } catch (e2) {
-  }
-})();
-var PM_TOOL_PARAMETER_PROPERTIES = {
-  json: { type: "boolean", default: true },
-  quiet: { type: "boolean" },
-  profile: { type: "boolean" },
-  noExtensions: { type: "boolean" },
-  noPager: { type: "boolean" },
-  path: { type: "string" },
-  pmExecutable: { type: "string" },
-  timeoutMs: { type: "number" },
-  id: { type: "string" },
-  target: { type: "string" },
-  output: { type: "string", minLength: 1 },
-  github: { type: "string" },
-  ref: { type: "string" },
-  query: { type: "string" },
-  keywords: { type: "string" },
-  fields: { type: "string" },
-  sort: { type: "string", enum: ["priority", "deadline", "updated_at", "created_at", "title", "parent"] },
-  prefix: { type: "string" },
-  preset: { type: "string", enum: ["minimal", "default", "strict", "custom"] },
-  typePreset: { type: "string", enum: ["agile", "ops", "research"] },
-  defaults: { type: "boolean" },
-  verbose: { type: "boolean" },
-  agentGuidance: { type: "string", enum: ["ask", "add", "skip", "status"] },
-  withPackages: { type: "boolean" },
-  scope: { type: "string", enum: ["project", "global"] },
-  allOver: { type: "number" },
-  minEntries: { type: "number" },
-  closed: { type: "boolean" },
-  allStreams: { type: "boolean" },
-  contractAction: { type: "string" },
-  command: { type: "string" },
-  schemaOnly: { type: "boolean" },
-  flagsOnly: { type: "boolean" },
-  availabilityOnly: { type: "boolean" },
-  runtimeOnly: { type: "boolean" },
-  activeOnly: { type: "boolean" },
-  eagerTags: { type: "boolean" },
-  fullChangedFields: { type: "boolean" },
-  idOnly: { type: "boolean" },
-  allowMissingParent: { type: "boolean" },
-  duplicateOf: { type: "string" },
-  configAction: { type: "string", enum: ["get", "set", "list", "export"] },
-  key: { type: "string" },
-  title: { type: "string" },
-  description: { type: "string" },
-  type: { type: "string" },
-  template: { type: "string" },
-  createMode: { type: "string", enum: ["strict", "progressive"] },
-  schedulePreset: { type: "string", enum: ["lightweight"] },
-  status: { type: "string" },
-  filterStatus: { type: "string" },
-  filterType: { type: "string" },
-  filterTag: { type: "string" },
-  filterPriority: { anyOf: [{ type: "string" }, { type: "number" }] },
-  filterDeadlineBefore: { type: "string" },
-  filterDeadlineAfter: { type: "string" },
-  filterUpdatedAfter: { type: "string" },
-  filterUpdatedBefore: { type: "string" },
-  filterCreatedAfter: { type: "string" },
-  filterCreatedBefore: { type: "string" },
-  filterAssignee: { type: "string" },
-  filterAssigneeFilter: { type: "string", enum: ["assigned", "unassigned"] },
-  filterParent: { type: "string" },
-  filterSprint: { type: "string" },
-  filterRelease: { type: "string" },
-  closeReason: { type: "string" },
-  reason: { type: "string" },
-  priority: { anyOf: [{ type: "string" }, { type: "number" }] },
-  tags: { type: "string" },
-  addTags: { type: "array", items: { type: "string" } },
-  removeTags: { type: "array", items: { type: "string" } },
-  body: { type: "string" },
-  deadline: { type: "string" },
-  estimate: { anyOf: [{ type: "string" }, { type: "number" }] },
-  acceptanceCriteria: { type: "string" },
-  author: { type: "string" },
-  message: { type: "string" },
-  assignee: { type: "string" },
-  assigneeFilter: { type: "string", enum: ["assigned", "unassigned"] },
-  parent: { type: "string" },
-  reviewer: { type: "string" },
-  risk: { type: "string" },
-  confidence: { anyOf: [{ type: "string" }, { type: "number" }] },
-  sprint: { type: "string" },
-  release: { type: "string" },
-  blockedBy: { type: "string" },
-  blockedReason: { type: "string" },
-  unblockNote: { type: "string" },
-  reporter: { type: "string" },
-  severity: { type: "string" },
-  environment: { type: "string" },
-  reproSteps: { type: "string" },
-  resolution: { type: "string" },
-  expectedResult: { type: "string" },
-  actualResult: { type: "string" },
-  affectedVersion: { type: "string" },
-  fixedVersion: { type: "string" },
-  component: { type: "string" },
-  regression: { anyOf: [{ type: "boolean" }, { type: "string" }, { type: "number" }] },
-  customerImpact: { type: "string" },
-  definitionOfReady: { type: "string" },
-  order: { anyOf: [{ type: "string" }, { type: "number" }] },
-  goal: { type: "string" },
-  objective: { type: "string" },
-  value: { type: "string" },
-  impact: { type: "string" },
-  outcome: { type: "string" },
-  whyNow: { type: "string" },
-  mode: {
-    type: "string",
-    enum: ["keyword", "semantic", "hybrid", "title_exact", "title_fuzzy", "parent_scope"]
-  },
-  semanticWeight: { anyOf: [{ type: "string" }, { type: "number" }] },
-  op: { type: "string" },
-  compact: { type: "boolean" },
-  brief: { type: "boolean" },
-  full: { type: "boolean" },
-  view: { type: "string", enum: ["agenda", "day", "week", "month"] },
-  date: { type: "string" },
-  from: { type: "string" },
-  before: { type: "string" },
-  to: { type: "string" },
-  past: { type: "boolean" },
-  fullPeriod: { type: "boolean" },
-  include: { type: "string" },
-  recurrenceLookaheadDays: { anyOf: [{ type: "string" }, { type: "number" }] },
-  recurrenceLookbackDays: { anyOf: [{ type: "string" }, { type: "number" }] },
-  occurrenceLimit: { anyOf: [{ type: "string" }, { type: "number" }] },
-  includeLinked: { type: "boolean" },
-  semantic: { type: "boolean" },
-  hybrid: { type: "boolean" },
-  titleExact: { type: "boolean" },
-  phraseExact: { type: "boolean" },
-  highlight: { type: "boolean" },
-  includeBody: { type: "boolean" },
-  noTruncate: { type: "boolean" },
-  tag: { type: "string" },
-  deadlineBefore: { type: "string" },
-  deadlineAfter: { type: "string" },
-  updatedAfter: { type: "string" },
-  updatedBefore: { type: "string" },
-  createdAfter: { type: "string" },
-  createdBefore: { type: "string" },
-  filterAcMissing: { type: "boolean" },
-  filterEstimatesMissing: { type: "boolean" },
-  filterResolutionMissing: { type: "boolean" },
-  filterMetadataMissing: { type: "boolean" },
-  filterReviewerMissing: { type: "boolean" },
-  filterRiskMissing: { type: "boolean" },
-  filterConfidenceMissing: { type: "boolean" },
-  filterSprintMissing: { type: "boolean" },
-  filterReleaseMissing: { type: "boolean" },
-  // Content-field presence/absence filters (list/search). The --no-* variants
-  // select items where the field is empty/absent.
-  hasNotes: { type: "boolean" },
-  noNotes: { type: "boolean" },
-  hasLearnings: { type: "boolean" },
-  noLearnings: { type: "boolean" },
-  hasFiles: { type: "boolean" },
-  noFiles: { type: "boolean" },
-  hasDocs: { type: "boolean" },
-  noDocs: { type: "boolean" },
-  hasTests: { type: "boolean" },
-  noTests: { type: "boolean" },
-  hasComments: { type: "boolean" },
-  noComments: { type: "boolean" },
-  hasDeps: { type: "boolean" },
-  noDeps: { type: "boolean" },
-  hasBody: { type: "boolean" },
-  emptyBody: { type: "boolean" },
-  hasLinkedCommand: { type: "boolean" },
-  noLinkedCommand: { type: "boolean" },
-  // Bulk-selection (update-many/close-many) content + governance filters mirror
-  // the list/search presence filters under the --filter- prefix.
-  filterHasNotes: { type: "boolean" },
-  filterNoNotes: { type: "boolean" },
-  filterHasLearnings: { type: "boolean" },
-  filterNoLearnings: { type: "boolean" },
-  filterHasFiles: { type: "boolean" },
-  filterNoFiles: { type: "boolean" },
-  filterHasDocs: { type: "boolean" },
-  filterNoDocs: { type: "boolean" },
-  filterHasTests: { type: "boolean" },
-  filterNoTests: { type: "boolean" },
-  filterHasComments: { type: "boolean" },
-  filterNoComments: { type: "boolean" },
-  filterHasDeps: { type: "boolean" },
-  filterNoDeps: { type: "boolean" },
-  filterHasBody: { type: "boolean" },
-  filterEmptyBody: { type: "boolean" },
-  filterHasLinkedCommand: { type: "boolean" },
-  filterNoLinkedCommand: { type: "boolean" },
-  ids: { type: "string" },
-  limit: { anyOf: [{ type: "string" }, { type: "number" }] },
-  blockedLimit: { anyOf: [{ type: "string" }, { type: "number" }] },
-  readyOnly: { type: "boolean" },
-  limitItems: { anyOf: [{ type: "string" }, { type: "number" }] },
-  fullHistory: { type: "boolean" },
-  latest: { anyOf: [{ type: "string" }, { type: "number" }] },
-  offset: { anyOf: [{ type: "string" }, { type: "number" }] },
-  progress: { type: "boolean" },
-  background: { type: "boolean" },
-  runId: { type: "string" },
-  stream: {
-    anyOf: [{ type: "boolean" }, { type: "string", enum: ["stdout", "stderr", "both", "rows", "ndjson", "jsonl"] }]
-  },
-  tail: { anyOf: [{ type: "string" }, { type: "number" }] },
-  addJson: { type: "array", items: { type: "string" } },
-  match: { type: "string" },
-  onlyIndex: { anyOf: [{ type: "string" }, { type: "number" }] },
-  onlyLast: { type: "boolean" },
-  envSet: { type: "array", items: { type: "string" } },
-  envClear: { type: "array", items: { type: "string" } },
-  sharedHostSafe: { type: "boolean" },
-  detail: { type: "string", enum: ["summary", "deep"] },
-  trace: { type: "boolean" },
-  reload: { type: "boolean" },
-  watch: { type: "boolean" },
-  runtimeProbe: { type: "boolean" },
-  fixManagedState: { type: "boolean" },
-  pmContext: { type: "string", enum: ["schema", "tracker", "auto"] },
-  overrideLinkedPmContext: { type: "boolean" },
-  failOnContextMismatch: { type: "boolean" },
-  failOnSkipped: { type: "boolean" },
-  failOnEmptyTestRun: { type: "boolean" },
-  requireAssertionsForPm: { type: "boolean" },
-  checkContext: { type: "boolean" },
-  autoPmContext: { type: "boolean" },
-  diff: { type: "boolean" },
-  storage: { type: "boolean" },
-  metadataCoverage: { type: "boolean" },
-  fieldUtilization: { type: "boolean" },
-  byAssignee: { type: "boolean" },
-  byTag: { type: "boolean" },
-  byPriority: { type: "boolean" },
-  tagPrefix: { type: "string" },
-  verify: { type: "boolean" },
-  literal: { type: "array", items: { type: "string" } },
-  regex: { type: "array", items: { type: "string" } },
-  replacement: { type: "string" },
-  timeout: { anyOf: [{ type: "string" }, { type: "number" }] },
-  validateClose: { type: "string", enum: ["off", "warn", "strict"] },
-  checkMetadata: { type: "boolean" },
-  metadataProfile: { type: "string", enum: ["core", "strict", "custom"] },
-  checkResolution: { type: "boolean" },
-  checkLifecycle: { type: "boolean" },
-  checkStaleBlockers: { type: "boolean" },
-  dependencyCycleSeverity: { type: "string", enum: ["off", "warn", "error"] },
-  parentCycleSeverity: { type: "string", enum: ["off", "warn", "error"] },
-  checkFiles: { type: "boolean" },
-  strictDirectories: { type: "boolean" },
-  checkOnly: { type: "boolean" },
-  checkTelemetry: { type: "boolean" },
-  noRefresh: { type: "boolean" },
-  refreshVectors: { type: "boolean" },
-  verboseStaleItems: { type: "boolean" },
-  skipVectors: { type: "boolean" },
-  skipIntegrity: { type: "boolean" },
-  skipDrift: { type: "boolean" },
-  verboseDiagnostics: { type: "boolean" },
-  allAffectedIds: { type: "boolean" },
-  scanMode: { type: "string", enum: ["default", "tracked-all", "tracked-all-strict"] },
-  includePmInternals: { type: "boolean" },
-  verboseFileLists: { type: "boolean" },
-  strictExit: { type: "boolean" },
-  failOnWarn: { type: "boolean" },
-  fixHints: { type: "boolean" },
-  autoFix: { type: "boolean" },
-  fixScope: { type: "array", items: { type: "string", enum: ["metadata", "resolution", "estimates", "lifecycle"] } },
-  pruneMissing: { type: "boolean" },
-  checkHistoryDrift: { type: "boolean" },
-  checkCommandReferences: { type: "boolean" },
-  allowAuditNote: { type: "boolean" },
-  allowAuditLearning: { type: "boolean" },
-  allowAuditComment: { type: "boolean" },
-  edit: { type: "integer", minimum: 1 },
-  delete: { type: "integer", minimum: 1 },
-  allowAuditUpdate: { type: "boolean" },
-  allowAuditDepUpdate: { type: "boolean" },
-  allowAuditRelease: { type: "boolean" },
-  dryRun: { type: "boolean" },
-  all: { type: "boolean" },
-  clear: { type: "boolean" },
-  cliOnly: { type: "boolean" },
-  packagesOnly: { type: "boolean" },
-  repair: { type: "boolean" },
-  packageName: { type: "string" },
-  rollback: { type: "string" },
-  noCheckpoint: { type: "boolean" },
-  force: { type: "boolean" },
-  run: { type: "boolean" },
-  count: { type: "boolean" },
-  sum: { type: "string" },
-  avg: { type: "string" },
-  tree: { type: "boolean" },
-  treeDepth: { anyOf: [{ type: "string" }, { type: "number" }] },
-  includeUnparented: { type: "boolean" },
-  gcScope: {
-    type: "array",
-    items: { type: "string", enum: ["index", "embeddings", "runtime", "locks"] }
-  },
-  maxDepth: { anyOf: [{ type: "string" }, { type: "number" }] },
-  collapse: { type: "string", enum: ["none", "repeated"] },
-  summary: { type: "boolean" },
-  shell: { type: "string", enum: ["bash", "zsh", "fish"] },
-  stdin: { type: "boolean" },
-  file: { type: "string" },
-  preserveSourceIds: { type: "boolean" },
-  folder: { type: "string" },
-  subcommand: { type: "string" },
-  name: { type: "string" },
-  defaultStatus: { type: "string" },
-  alias: { type: "array", items: { type: "string" } },
-  role: { type: "array", items: { type: "string" } },
-  fieldType: { type: "string", enum: ["string", "number", "boolean", "string_array"] },
-  commands: { type: "array", items: { type: "string" } },
-  cliFlag: { type: "string" },
-  required: { type: "boolean" },
-  requiredOnCreate: { type: "boolean" },
-  allowUnset: { type: "boolean" },
-  requiredTypes: { type: "array", items: { type: "string" } },
-  infer: { type: "boolean" },
-  minCount: { type: "number" },
-  text: { type: "string" },
-  add: { type: "array", items: { type: "string" } },
-  addGlob: { type: "array", items: { type: "string" } },
-  remove: { type: "array", items: { type: "string" } },
-  migrate: { type: "array", items: { type: "string" } },
-  discover: { type: "boolean" },
-  apply: { type: "boolean" },
-  discoveryNote: { type: "string" },
-  // GH-170 (pm-pfnx): single-string note for files/docs add batches (the shared
-  // `note` key below is the array-typed create/update note seed).
-  addNote: { type: "string" },
-  list: { type: "boolean" },
-  appendStable: { type: "boolean" },
-  validatePaths: { type: "boolean" },
-  audit: { type: "boolean" },
-  dep: { type: "array", items: { type: "string" } },
-  depRemove: { type: "array", items: { type: "string" } },
-  replaceDeps: { type: "boolean" },
-  replaceTests: { type: "boolean" },
-  comment: { type: "array", items: { type: "string" } },
-  note: { type: "array", items: { type: "string" } },
-  learning: { type: "array", items: { type: "string" } },
-  linkedFile: { type: "array", items: { type: "string" } },
-  linkedTest: { type: "array", items: { type: "string" } },
-  doc: { type: "array", items: { type: "string" } },
-  reminder: { type: "array", items: { type: "string" } },
-  event: { type: "array", items: { type: "string" } },
-  typeOption: { type: "array", items: { type: "string" } },
-  field: { type: "array", items: { type: "string" } },
-  unset: { type: "array", items: { type: "string" } },
-  clearDeps: { type: "boolean" },
-  clearComments: { type: "boolean" },
-  clearNotes: { type: "boolean" },
-  clearLearnings: { type: "boolean" },
-  clearFiles: { type: "boolean" },
-  clearTests: { type: "boolean" },
-  clearDocs: { type: "boolean" },
-  clearReminders: { type: "boolean" },
-  clearEvents: { type: "boolean" },
-  clearTypeOptions: { type: "boolean" },
-  criterion: { type: "array", items: { type: "string" } },
-  clearCriteria: { type: "boolean" },
-  groupBy: { type: "string" },
-  completion: { type: "boolean" },
-  threshold: { anyOf: [{ type: "string" }, { type: "number" }] },
-  format: { type: "string" },
-  depth: { type: "string", enum: ["brief", "standard", "deep", "full"] },
-  section: { type: "array", items: { type: "string", enum: ["hierarchy", "activity", "progress", "blockers", "files", "workload", "staleness", "tests"] } },
-  activityLimit: { anyOf: [{ type: "string" }, { type: "number" }] },
-  staleThreshold: { type: "string" },
-  policy: { type: "string" }
-};
-var PLAN_SUBCOMMAND_VALUES = [
-  "create",
-  "show",
-  "add-step",
-  "update-step",
-  "complete-step",
-  "block-step",
-  "reorder-step",
-  "remove-step",
-  "link",
-  "unlink",
-  "decision",
-  "discovery",
-  "validation",
-  "resume",
-  "approve",
-  "materialize"
-];
-var PLAN_ACTION_PARAMETER_PROPERTIES = {
-  subcommand: { type: "string", enum: [...PLAN_SUBCOMMAND_VALUES] },
-  stepRef: { type: "string" },
-  reorderTo: { anyOf: [{ type: "string" }, { type: "number" }] },
-  scope: { type: "string" },
-  harness: { type: "string", enum: [...PLAN_HARNESS_VALUES] },
-  mode: { type: "string", enum: [...PLAN_MODE_VALUES] },
-  resumeContext: { type: "string" },
-  related: { type: "string" },
-  blocks: { type: "string" },
-  claim: { type: "boolean" },
-  fromSearch: { type: "string" },
-  stepTitle: { type: "string" },
-  // pm-6mit: ordered step titles for create (string or array; values are never
-  // comma-split). On step subcommands a single value aliases stepTitle.
-  step: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
-  stepBody: { type: "string" },
-  stepOwner: { type: "string" },
-  stepStatus: { type: "string", enum: [...PLAN_STEP_STATUS_VALUES] },
-  stepEvidence: { type: "string" },
-  stepBlockedReason: { type: "string" },
-  stepReplacement: { type: "string" },
-  dependsOn: { type: "string" },
-  link: { type: "string" },
-  linkKind: { type: "string", enum: [...PLAN_STEP_LINK_KIND_VALUES] },
-  linkNote: { type: "string" },
-  promoteToItemDep: { type: "boolean" },
-  allowMultipleActive: { type: "boolean" },
-  file: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
-  test: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
-  doc: { anyOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
-  decisionText: { type: "string" },
-  decision: { type: "string" },
-  decisionRationale: { type: "string" },
-  decisionEvidence: { type: "string" },
-  discoveryText: { type: "string" },
-  discovery: { type: "string" },
-  validationText: { type: "string" },
-  validation: { type: "string" },
-  validationCommand: { type: "string" },
-  validationExpected: { type: "string" },
-  steps: { type: "array", items: { type: "string" } },
-  materializeType: { type: "string" },
-  materializeParent: { type: "string" },
-  materializeTags: { type: "string" }
-};
-var PLAN_ACTION_PARAMETER_METADATA = {
-  subcommand: {
-    description: "Plan workflow operation to run.",
-    examples: ["create", "show", "add-step", "approve"]
-  },
-  stepRef: {
-    description: "Plan step id or order for step lifecycle subcommands.",
-    examples: ["plan-step-001", "1"]
-  },
-  reorderTo: {
-    description: "New integer order for reorder-step.",
-    examples: [1, "2"]
-  },
-  scope: {
-    description: "Short free-text scope statement describing what the Plan covers.",
-    examples: ["Release readiness audit", "Search package migration"]
-  },
-  mode: {
-    description: "Plan lifecycle mode.",
-    examples: ["draft", "research", "approved"]
-  },
-  step: {
-    description: "Ordered initial step titles for create (string or array, never comma-split; stepTitle, when also set, becomes the first step). For step subcommands a single value aliases stepTitle.",
-    examples: [["Read the code", "Write the fix", "Run the tests"]]
-  },
-  file: {
-    description: "File link to attach while creating or materializing a Plan.",
-    examples: ["path=src/cli.ts,note=implementation surface"]
-  },
-  test: {
-    description: "Test command link to attach while creating or materializing a Plan.",
-    examples: ["command=pnpm build,timeout_seconds=300"]
-  },
-  doc: {
-    description: "Documentation link to attach while creating or materializing a Plan.",
-    examples: ["path=docs/SDK.md,note=public API reference"]
-  }
-};
-var PM_TOOL_PARAMETER_METADATA = {
-  action: {
-    description: "Tool action to execute."
-  },
-  path: {
-    description: "Optional PM data root override for this invocation.",
-    examples: [".agents/pm"]
-  },
-  scope: {
-    description: "Scope selector for commands that operate on project or global state. Linked files, docs, and tests default to project scope when omitted.",
-    examples: ["project", "global"]
-  },
-  detail: {
-    description: "Detail mode for commands that support concise and deep diagnostics.",
-    examples: ["summary", "deep"]
-  },
-  trace: {
-    description: "When true for extension-doctor, include actionable registration traces in deep diagnostics."
-  },
-  reload: {
-    description: "When true for extension action payloads, trigger cache-busted extension module reload."
-  },
-  watch: {
-    description: "When true for extension-reload/extension action payloads, enable watch mode semantics."
-  },
-  runtimeProbe: {
-    description: "When true for extension-manage, run a doctor-like runtime activation probe for parity fields."
-  },
-  fixManagedState: {
-    description: "When true for extension-manage/extension-doctor, adopt unmanaged extensions before diagnostics/update checks."
-  },
-  target: {
-    description: "Positional target argument for the selected action (ID, source, package source, or extension name).",
-    examples: ["pm-a1b2", ".agents/pm/extensions/sample", "sample-extension"]
-  },
-  output: {
-    description: "File path for commands that write generated output, such as package/extension describe Markdown references.",
-    examples: ["docs/pm-package-reference.md"]
-  },
-  github: {
-    description: "GitHub shorthand owner/repo[/path] source for package/extension install actions.",
-    examples: ["org/repo/extensions/sample"]
-  },
-  ref: {
-    description: "Git ref/branch/tag used when installing from GitHub shorthand/URL sources.",
-    examples: ["main", "v1.0.0"]
-  },
-  cliOnly: {
-    description: "Restrict upgrade to the pm CLI/SDK npm package."
-  },
-  packagesOnly: {
-    description: "Restrict upgrade to managed installable pm packages."
-  },
-  repair: {
-    description: "Force npm global reinstall semantics when upgrading the pm CLI/SDK."
-  },
-  tag: {
-    description: "npm version or dist-tag used for CLI and registry package upgrades.",
-    examples: ["latest", "next", "2026.5.11"]
-  },
-  packageName: {
-    description: "Override the pm CLI package name for self-upgrade automation and tests.",
-    examples: ["@unbrained/pm-cli"]
-  },
-  json: {
-    description: "Emit machine-readable JSON output."
-  },
-  quiet: {
-    description: "Suppress stdout payload output."
-  },
-  noExtensions: {
-    description: "Disable extension loading for this invocation."
-  },
-  noPager: {
-    description: "Disable pager integration for help and long output."
-  },
-  profile: {
-    description: "Emit deterministic timing diagnostics to stderr."
-  },
-  timeoutMs: {
-    description: "Tool execution timeout in milliseconds.",
-    examples: [12e4]
-  },
-  id: {
-    description: "Item identifier for read or mutation actions.",
-    examples: ["pm-a1b2"]
-  },
-  runId: {
-    description: "Background test run identifier.",
-    examples: ["tr-kq9x3f-93acde"]
-  },
-  title: {
-    description: "Item title text."
-  },
-  description: {
-    description: "Item description text."
-  },
-  type: {
-    description: "Item type name from the active runtime type registry.",
-    examples: ["Task", "Feature"]
-  },
-  subcommand: {
-    description: "Subcommand selector for schema, profile, and telemetry actions."
-  },
-  name: {
-    description: "Custom item type name (schema add-type/remove-type/show), custom status id (schema show-status/add-status/remove-status), custom field key (schema add-field/remove-field/show-field), or profile name (profile show/apply/lint).",
-    examples: ["Spike", "review", "component"]
-  },
-  defaultStatus: {
-    description: "Default status hint recorded for a custom item type.",
-    examples: ["open"]
-  },
-  alias: {
-    description: "Aliases for the custom item type or status (repeatable).",
-    examples: [["spike", "research"]]
-  },
-  role: {
-    description: "Lifecycle roles for a custom status (schema add-status): draft, active, blocked, terminal, terminal_done, terminal_canceled, default_open, default_close, default_cancel.",
-    examples: [["active"], ["terminal", "terminal_done"]]
-  },
-  fieldType: {
-    description: "Value type for a custom field (schema add-field): string, number, boolean, or string_array.",
-    examples: ["string", "number", "string_array"]
-  },
-  commands: {
-    description: "Commands a custom field is wired onto (schema add-field): create, update, update_many, list, search, calendar, context.",
-    examples: [["create", "update"], ["create", "update", "list"]]
-  },
-  cliFlag: {
-    description: "Override the auto-derived CLI flag for a custom field (schema add-field).",
-    examples: ["--owner"]
-  },
-  required: {
-    description: "Mark a custom field as always required (schema add-field)."
-  },
-  requiredOnCreate: {
-    description: "Mark a custom field as required at create time (schema add-field)."
-  },
-  allowUnset: {
-    description: "Whether a custom field may be cleared via --unset (schema add-field); defaults to true."
-  },
-  requiredTypes: {
-    description: "Restrict a custom field's requirement to specific item types (schema add-field).",
-    examples: [["Bug"], ["Story", "Spike"]]
-  },
-  infer: {
-    description: "Infer custom item types from title-prefix conventions (schema add-type); previews unless apply is true."
-  },
-  minCount: {
-    description: "Minimum number of items sharing a title prefix for schema add-type inference (default 10).",
-    examples: [10, 25]
-  },
-  preset: {
-    description: "Governance preset for initialization flows.",
-    examples: ["minimal", "default", "strict"]
-  },
-  typePreset: {
-    description: "Domain item-type preset registered during initialization.",
-    examples: ["agile", "ops", "research"]
-  },
-  defaults: {
-    description: "Use non-interactive setup defaults during initialization."
-  },
-  verbose: {
-    description: "Include the full resolved settings tree in init output."
-  },
-  agentGuidance: {
-    description: "Control AGENTS.md/CLAUDE.md guidance behavior during init: ask, add, skip, or status.",
-    examples: ["ask", "add", "skip", "status"]
-  },
-  withPackages: {
-    description: "Install all bundled first-party pm packages during initialization."
-  },
-  createMode: {
-    description: "Create required-option policy mode.",
-    examples: ["strict", "progressive"]
-  },
-  schedulePreset: {
-    description: "Schedule-centric create preset for Reminder, Meeting, and Event types.",
-    examples: ["lightweight"]
-  },
-  status: {
-    description: "Item status value. Statuses are project-configurable via .agents/pm/settings.json (schema block); the built-in defaults are draft, open, in_progress, blocked, closed, canceled. Custom statuses defined for the project are accepted \u2014 discover the active set with the pm_contracts tool (workspace.statuses) or `pm contracts`. Unknown statuses are rejected at runtime with a did-you-mean hint rather than blocked by a fixed schema enum.",
-    examples: ["open", "in_progress"]
-  },
-  priority: {
-    description: "Priority value in range 0..4.",
-    examples: [0, 1, "2"]
-  },
-  order: {
-    description: "Planning order/rank value for create/update, or sort direction (asc|desc) for list-family sorting.",
-    examples: [0, 1, "2", "asc", "desc"]
-  },
-  sort: {
-    description: "List-family sort field selector.",
-    examples: ["priority", "deadline", "updated_at", "created_at", "title", "parent"]
-  },
-  tags: {
-    description: "Comma-delimited tag list.",
-    examples: ["pm-cli,agent-ux"]
-  },
-  addTags: {
-    description: "Tags to add to the existing list without replacing it. Each entry may be CSV or a JSON array.",
-    examples: [["agent-ux"], ["fix", "security"]]
-  },
-  removeTags: {
-    description: "Tags to remove from the existing list. Each entry may be CSV or a JSON array.",
-    examples: [["stale"], ["legacy", "wontfix"]]
-  },
-  deadline: {
-    description: "ISO/date timestamp or relative offset (+6h/+1d/+2w/+6m).",
-    examples: ["2026-04-01T00:00:00.000Z", "+1d"]
-  },
-  reminder: {
-    description: "Repeatable reminder seed entries at=<iso|relative>,text=<text>.",
-    examples: [["at=+2d,text=Review PR"]]
-  },
-  event: {
-    description: "Repeatable event seed entries start=<iso|relative> with end=<iso|relative> or duration=<relative|30min|PT30M>. Bare `m` remains months for backward compatibility.",
-    examples: [
-      ["start=2026-07-01T10:00:00Z,duration=2h,title=planning"],
-      ["start=2026-07-01T10:00:00Z,duration=30min,title=standup"],
-      ["start=2026-07-01T10:00:00Z,duration=PT30M,title=window"]
-    ]
-  },
-  estimate: {
-    description: "Estimated effort in minutes.",
-    examples: [60, "120"]
-  },
-  acceptanceCriteria: {
-    description: "Acceptance criteria text."
-  },
-  author: {
-    description: "Mutation author identity.",
-    examples: ["codex-agent"]
-  },
-  message: {
-    description: "History message for mutation audit trail."
-  },
-  assignee: {
-    description: "Assignee identity.",
-    examples: ["codex-agent"]
-  },
-  assigneeFilter: {
-    description: "Assignee presence selector for list/calendar/context/comments-audit filters.",
-    examples: ["assigned", "unassigned"]
-  },
-  parent: {
-    description: "Parent item ID filter for hierarchical list queries.",
-    examples: ["pm-epic01"]
-  },
-  blockedLimit: {
-    description: "Cap blocked rows returned by the next action (defaults to the ready --limit).",
-    examples: ["3"]
-  },
-  readyOnly: {
-    description: "When true, the next action omits the blocked companion list."
-  },
-  unset: {
-    description: "Repeatable list of front-matter fields to clear explicitly during create/update mutations.",
-    examples: [["deadline", "assignee"], ["close-reason"]]
-  },
-  clearDeps: {
-    description: "When true, clear linked dependencies."
-  },
-  replaceDeps: {
-    description: "When true for update, atomically replace dependencies with the supplied --dep values."
-  },
-  replaceTests: {
-    description: "When true for update, atomically replace linked tests with the supplied --test values."
-  },
-  clearComments: {
-    description: "When true, clear item comments."
-  },
-  clearNotes: {
-    description: "When true, clear item notes."
-  },
-  clearLearnings: {
-    description: "When true, clear item learnings."
-  },
-  clearFiles: {
-    description: "When true, clear linked files."
-  },
-  clearTests: {
-    description: "When true, clear linked tests."
-  },
-  clearDocs: {
-    description: "When true, clear linked docs."
-  },
-  clearReminders: {
-    description: "When true, clear reminders."
-  },
-  clearEvents: {
-    description: "When true, clear events."
-  },
-  clearTypeOptions: {
-    description: "When true, clear type option metadata."
-  },
-  clearCriteria: {
-    description: "When true for config set criteria-list keys (definition-of-done, metadata-required-fields, lifecycle pattern lists), clear the criteria list."
-  },
-  mode: {
-    description: "Mode selector for search/reindex (keyword|semantic|hybrid) and dedupe-audit (title_exact|title_fuzzy|parent_scope).",
-    examples: ["keyword", "hybrid", "title_exact"]
-  },
-  semanticWeight: {
-    description: "Per-query hybrid semantic weight override in [0,1] for search action; invalid values fall back to settings.",
-    examples: [0.2, "0.7"]
-  },
-  op: {
-    description: "History operation filter for activity output.",
-    examples: ["create", "update", "close", "update_audit"]
-  },
-  fullPeriod: {
-    description: "For day/week/month calendar views, include the full anchored period instead of clipping the start to now."
-  },
-  progress: {
-    description: "Emit progress diagnostics to stderr for long-running operations."
-  },
-  background: {
-    description: "Run linked tests in managed background mode."
-  },
-  addJson: {
-    description: "Repeatable JSON object or array input for adding linked-test entries without CSV escaping loss.",
-    examples: [[`{"command":"node scripts/run-tests.mjs test -- tests/unit/output.spec.ts","timeout_seconds":240}`]]
-  },
-  match: {
-    description: "Run only linked tests whose command or path contains this case-insensitive substring.",
-    examples: ["output.spec.ts", "coverage"]
-  },
-  onlyIndex: {
-    description: "Run only the 1-based linked-test index from pm test <id> --list order.",
-    examples: [1, "2"]
-  },
-  onlyLast: {
-    description: "Run only the most recently added linked-test entry."
-  },
-  envSet: {
-    description: "Repeatable runtime environment KEY=VALUE overrides for linked-test execution.",
-    examples: [["PORT=0", "PLAYWRIGHT_HTML_OPEN=never"]]
-  },
-  envClear: {
-    description: "Repeatable runtime environment variable names to clear before linked-test execution.",
-    examples: [["PLAYWRIGHT_BASE_URL"]]
-  },
-  sharedHostSafe: {
-    description: "Apply additive shared-host-safe runtime defaults during linked-test execution."
-  },
-  pmContext: {
-    description: "PM linked-test context mode (schema keeps isolated tracker data; tracker seeds source tracker data; auto uses tracker for PM tracker-read linked commands).",
-    examples: ["schema", "tracker", "auto"]
-  },
-  overrideLinkedPmContext: {
-    description: "Force run-level --pm-context to override per-linked-test pm_context_mode metadata for all linked-test entries."
-  },
-  failOnContextMismatch: {
-    description: "Fail linked PM command runs when source and sandbox tracker item counts differ."
-  },
-  failOnSkipped: {
-    description: "Treat skipped linked tests as dependency-failed policy violations."
-  },
-  failOnEmptyTestRun: {
-    description: "Treat successful linked-test commands that report zero executed tests as failures."
-  },
-  requireAssertionsForPm: {
-    description: "Require assertion metadata for linked PM command test entries during run execution."
-  },
-  checkContext: {
-    description: "Run linked PM command context preflight diagnostics before command execution."
-  },
-  autoPmContext: {
-    description: "Auto-remediate PM tracker-read linked commands by routing those entries through tracker context regardless of linked-test pm_context_mode overrides."
-  },
-  dryRun: {
-    description: "Preview command effects without mutating storage artifacts."
-  },
-  all: {
-    description: "For history-repair action: scan every stream for drift and repair each drifted stream in one audited pass (mutually exclusive with id)."
-  },
-  clear: {
-    description: "For focus action: clear the session focused item instead of setting it (mutually exclusive with id)."
-  },
-  gcScope: {
-    description: "Repeatable gc scope selector values (index, embeddings, runtime, locks, checkpoints).",
-    examples: [["index", "embeddings"], ["runtime"], ["locks"], ["checkpoints"]]
-  },
-  storage: {
-    description: "For stats action: include aggregate history-stream storage metrics (total streams/lines/bytes, largest + deepest streams, oldest/newest entries) for compaction and storage planning."
-  },
-  fieldUtilization: {
-    description: "For stats action: include a field_utilization block reporting present/total/percent for content fields (notes, learnings, files, docs, tests, comments, deps, body, linked_command) across all items so under-documented dimensions are visible at a glance."
-  },
-  offset: {
-    description: "Number of matching rows to skip before limit is applied.",
-    examples: [0, 50, "100"]
-  },
-  before: {
-    description: "For history-compact, compact entries strictly before this boundary (version number or ISO timestamp). Single-id mode only.",
-    examples: ["5", "2026-06-01T00:00:00.000Z"]
-  },
-  allOver: {
-    description: "For history-compact bulk mode, compact every stream with more than N entries. When history.compact_policy is enabled and this is omitted, the policy's max_entries is used.",
-    examples: [200, "500"]
-  },
-  minEntries: {
-    description: "For history-compact bulk mode, skip streams with at most N entries as already-compact (default 3).",
-    examples: [3, "10"]
-  },
-  closed: {
-    description: "For history-compact bulk mode, compact only closed (terminal) items' history streams."
-  },
-  allStreams: {
-    description: "For history-compact bulk mode, compact every history stream regardless of lifecycle state."
-  },
-  limitItems: {
-    description: "Maximum number of filtered items to include in comments-audit output (alias: --limit).",
-    examples: [10, "25"]
-  },
-  fullHistory: {
-    description: "When true for comments-audit, export full per-item comment history rows; cannot be combined with latest."
-  },
-  latest: {
-    description: "Number of most recent comments to include per item in comments-audit output (use 0 for summary-only item rows).",
-    examples: [0, 1, "3"]
-  },
-  literal: {
-    description: "Repeatable literal matcher used by history-redact to scrub exact string values.",
-    examples: ["[redacted_path_prefix]/private/path"]
-  },
-  regex: {
-    description: "Repeatable regex matcher used by history-redact. Accepts either /pattern/flags or a raw pattern (global mode is auto-enabled).",
-    examples: ["/192\\\\.168\\\\.[0-9.]+/g", "token=[A-Za-z0-9_-]+"]
-  },
-  replacement: {
-    description: 'Replacement text used by history-redact (defaults to "[redacted]").',
-    examples: ["[scrubbed_path]"]
-  },
-  validateClose: {
-    description: 'Close-time metadata validation mode ("off", "warn", or "strict").',
-    examples: ["off", "warn", "strict"]
-  },
-  checkMetadata: {
-    description: "Run metadata completeness checks."
-  },
-  metadataProfile: {
-    description: "Select metadata validation profile for --check-metadata.",
-    examples: ["core", "strict", "custom"]
-  },
-  checkResolution: {
-    description: "Run closed-item resolution metadata checks."
-  },
-  checkLifecycle: {
-    description: "Run active-item lifecycle governance drift checks."
-  },
-  checkStaleBlockers: {
-    description: "Include stale blocker-pattern diagnostics in lifecycle checks."
-  },
-  dependencyCycleSeverity: {
-    description: "Set dependency-cycle warning policy for lifecycle checks.",
-    examples: ["off", "warn", "error"]
-  },
-  parentCycleSeverity: {
-    description: "Set parent-cycle warning policy for lifecycle checks.",
-    examples: ["off", "warn", "error"]
-  },
-  checkFiles: {
-    description: "Run linked-file and orphaned-file checks."
-  },
-  strictDirectories: {
-    description: "Treat optional item-type directories as required health failures."
-  },
-  checkOnly: {
-    description: "For health action, run read-only diagnostics without refreshing vectors."
-  },
-  checkTelemetry: {
-    description: "For health action, probe telemetry endpoint health and include network diagnostics."
-  },
-  noRefresh: {
-    description: "For health action, skip vector refresh while still running checks."
-  },
-  refreshVectors: {
-    description: "For health action, explicitly refresh stale vectors."
-  },
-  verboseStaleItems: {
-    description: "For health action, include full stale-item arrays in vectorization details."
-  },
-  skipVectors: {
-    description: "For health action, skip vectorization checks for a faster diagnostic run."
-  },
-  skipIntegrity: {
-    description: "For health action, skip item/history file integrity checks for a faster diagnostic run."
-  },
-  skipDrift: {
-    description: "For health action, skip history drift hash checks for a faster diagnostic run."
-  },
-  scanMode: {
-    description: "Select file candidate scan mode for --check-files.",
-    examples: ["default", "tracked-all", "tracked-all-strict"]
-  },
-  includePmInternals: {
-    description: "Include PM storage internals in tracked-all candidate scans."
-  },
-  verboseFileLists: {
-    description: "For validate action, include full file-path lists for --check-files details."
-  },
-  verboseDiagnostics: {
-    description: "For validate action, include full diagnostic ID lists instead of compact summaries."
-  },
-  strictExit: {
-    description: "Return non-zero exit when health/validate/extension-doctor warnings are present."
-  },
-  failOnWarn: {
-    description: "Alias for strictExit in health/validate/extension-doctor action payloads."
-  },
-  fixHints: {
-    description: "For validate action, add a machine-executable fix_hints[] of pm commands to each failing check's details."
-  },
-  autoFix: {
-    description: "For validate action, apply the safe, deterministic subset of fix-hint remediations (field backfills) automatically; combine with dryRun to preview and fixScope to grant gated scopes."
-  },
-  fixScope: {
-    description: "For validate action, grant --auto-fix scopes (metadata, resolution, estimates, lifecycle). Defaults to the safe scopes metadata and resolution; estimates (per-type default estimated_minutes backfill) and lifecycle must be named explicitly.",
-    examples: [["estimates"], ["lifecycle"], ["metadata", "resolution"]]
-  },
-  pruneMissing: {
-    description: "For validate action, remove stale linked-file/doc LINKS whose paths classified as deleted (link removal only \u2014 never touches real files); honors dryRun."
-  },
-  checkHistoryDrift: {
-    description: "Run item/history hash drift checks."
-  },
-  checkCommandReferences: {
-    description: "Run linked-command PM-ID reference checks."
-  },
-  allowAuditNote: {
-    description: "For notes action, allow non-owner append-only note audits without requiring --force."
-  },
-  allowAuditLearning: {
-    description: "For learnings action, allow non-owner append-only learning audits without requiring --force."
-  },
-  allowAuditComment: {
-    description: "For comments action, allow non-owner append-only comment audits without requiring --force."
-  },
-  edit: {
-    description: "For comments action, replace the comment at this 1-based index with the supplied replacement text (add/stdin/file)."
-  },
-  delete: {
-    description: "For comments action, delete the comment at this 1-based index."
-  },
-  stdin: {
-    description: "When true for comments action, read comment text from piped stdin (supports multiline markdown)."
-  },
-  file: {
-    description: "Path to input file for actions that read payload text, such as comments --file.",
-    examples: ["notes/comment.md"]
-  },
-  allowAuditUpdate: {
-    description: "Allow non-owner metadata-only update audits without requiring --force."
-  },
-  allowAuditDepUpdate: {
-    description: "Allow non-owner append-only dependency update audits without requiring --force."
-  },
-  allowAuditRelease: {
-    description: "Allow non-owner release handoffs that clear assignee metadata without requiring --force."
-  },
-  preserveSourceIds: {
-    description: "Preserve explicit source IDs during Beads imports instead of normalizing to tracker prefix.",
-    examples: [true]
-  },
-  appendStable: {
-    description: "When true for files action, preserve existing linked-file order and append new links without full-array resorting."
-  },
-  discover: {
-    description: "When true for files action, use `pm files discover <id>` to scan item text for referenced file paths."
-  },
-  apply: {
-    description: "Persist changes instead of returning a dry-run preview: for files discovery, add the missing discovered file links; for schema add-type --infer, register the inferred custom item types."
-  },
-  discoveryNote: {
-    description: "Note attached to file links added by files discovery.",
-    examples: ["discovered from item text"]
-  },
-  addNote: {
-    description: "Note attached to every link added by add/addGlob in this call (per-entry embedded note= wins; requires add or addGlob). Maps to the CLI --note flag on pm files/pm docs.",
-    examples: ["command wiring"]
-  },
-  list: {
-    description: "When true, list command-specific entries without mutating state (for example linked paths for files/docs or topics for guide).",
-    examples: [true]
-  },
-  stream: {
-    description: "Stream selector: test-runs logs accepts stdout|stderr|both; activity accepts boolean/rows|ndjson|jsonl for line-delimited output.",
-    examples: ["stderr", "stdout", "both", "rows", "ndjson", "jsonl", true]
-  },
-  tail: {
-    description: "Number of lines to tail for background run logs.",
-    examples: [100]
-  },
-  query: {
-    description: "Search query text for search action."
-  },
-  keywords: {
-    description: "Alias for query in search action payloads."
-  },
-  includeLinked: {
-    description: "Include readable linked docs/files/tests content in keyword and hybrid lexical scoring."
-  },
-  titleExact: {
-    description: "For search action, require exact normalized title match for the full query string."
-  },
-  phraseExact: {
-    description: "For search action, require exact normalized query phrase match in item text fields."
-  },
-  highlight: {
-    description: "For search action, emit per-field matched-text snippets (wrapped in \xAB\u2026\xBB) on each hit. Off by default."
-  },
-  includeBody: {
-    description: "When true for list-family actions, include item body text in projected rows."
-  },
-  noTruncate: {
-    description: "When true for list-family actions, return every matched row, overriding any limit (surfaces total when rows were dropped)."
-  },
-  compact: {
-    description: "Render compact projection output for search and list-family actions."
-  },
-  brief: {
-    description: "Emit compact low-token output for commands that support terse projections or health details.",
-    examples: [true]
-  },
-  full: {
-    description: "Enable command-specific full/detail output mode when supported, such as deep item reads for get or full payload mode for search/history."
-  },
-  fields: {
-    description: "Comma-separated projection fields for get, search, list-family, or context outputs. Valid field names are command-specific (e.g. score/matched_fields apply to search; context projects focus-row fields such as priority/deadline/completion_pct).",
-    examples: ["id,title,status,parent,type", "id,title,score,matched_fields", "id,title,priority,deadline"]
-  },
-  groupBy: {
-    description: "Comma-separated aggregate grouping fields (supported: parent,type,priority,status,assignee,tags,sprint,release).",
-    examples: ["parent,type", "type,status", "priority,assignee", "tags", "sprint,release"]
-  },
-  count: {
-    description: "Enable grouped count output for aggregate action."
-  },
-  completion: {
-    description: "For aggregate action, add open/in_progress/closed/other counts and completion_pct per group."
-  },
-  sum: {
-    description: "Numeric field to sum per aggregate group (count and null_count are still returned).",
-    examples: ["estimated_minutes", "priority"]
-  },
-  avg: {
-    description: "Numeric field to average per aggregate group (count and null_count are still returned).",
-    examples: ["estimated_minutes", "priority"]
-  },
-  tree: {
-    description: "When true for list/get actions, render recursive parent/child tree ordering."
-  },
-  treeDepth: {
-    description: "Maximum recursion depth for tree output (0 keeps root rows only).",
-    examples: [0, 1, "2"]
-  },
-  includeUnparented: {
-    description: "Include unparented rows when aggregate grouping includes parent."
-  },
-  maxDepth: {
-    description: "Maximum dependency traversal depth for deps action (0 keeps only the root node).",
-    examples: [0, 1, "2"]
-  },
-  collapse: {
-    description: 'Dependency tree collapse mode for deps action ("none" or "repeated").',
-    examples: ["none", "repeated"]
-  },
-  summary: {
-    description: "When true for deps action, return counts only without full tree/graph payloads."
-  },
-  threshold: {
-    description: "Dedupe-audit fuzzy title similarity threshold between 0 and 1.",
-    examples: [0.5, "0.75"]
-  },
-  shell: {
-    description: "Shell target for completion generation.",
-    examples: ["bash"]
-  },
-  eagerTags: {
-    description: "When true for completion, eagerly embed current tracker tags into generated scripts (legacy mode)."
-  },
-  contractAction: {
-    description: "Filter contracts schema to one tool action.",
-    examples: ["create", "update"]
-  },
-  command: {
-    description: "Scope contracts output to one CLI command name; action/schema surfaces narrow by default.",
-    examples: ["create", "search", "list"]
-  },
-  schemaOnly: {
-    description: "When true, contracts action returns schema-focused payloads (mutually exclusive with flagsOnly/availabilityOnly)."
-  },
-  flagsOnly: {
-    description: "When true, contracts action returns only command flag surface payloads (mutually exclusive projection mode)."
-  },
-  availabilityOnly: {
-    description: "When true, contracts action returns only action availability payloads (mutually exclusive projection mode)."
-  },
-  runtimeOnly: {
-    description: "When true, contracts action only includes actions invocable in the current runtime."
-  },
-  activeOnly: {
-    description: "Alias for runtimeOnly in contracts action payloads."
-  },
-  depth: {
-    description: "Context depth level controlling how many sections are included (brief=focus+agenda, standard=+hierarchy/activity/progress/workload, deep=all sections, full=every section with no per-section row cap).",
-    examples: ["brief", "standard", "deep", "full"]
-  },
-  section: {
-    description: "Repeatable section selector for context; overrides --depth when provided.",
-    examples: [["hierarchy", "activity"], ["blockers", "files", "staleness"]]
-  },
-  activityLimit: {
-    description: "Maximum number of recent activity entries to include in context output.",
-    examples: [5, 10, "20"]
-  },
-  staleThreshold: {
-    description: "Staleness cutoff in days for context staleness section (e.g. 7 or 7d).",
-    examples: ["7", "14d", "30"]
-  }
-};
-var PM_TOOL_ACTION_SCOPED_PARAMETER_METADATA = {
-  schema: {
-    name: {
-      description: "Custom item type name (add-type/remove-type/show), custom status id (show-status/add-status/remove-status), or custom field key (add-field/remove-field/show-field). Required for those subcommands.",
-      examples: ["Spike", "review", "component"]
-    }
-  },
-  profile: {
-    name: {
-      description: "Profile name for show/apply/lint. Built-in profiles are agile, ops, and research; an active extension can contribute additional archetype names that resolve here too.",
-      examples: ["agile", "ops", "research"]
-    }
-  }
-};
-
-// dist/sdk/cli-contracts/tool-schema.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] = "d9ede4a2-7ec3-5716-b623-8469cab14853");
-  } catch (e2) {
-  }
-})();
-var PM_TOOL_GLOBAL_PARAMETER_KEYS = [
-  "json",
-  "quiet",
-  "profile",
-  "noExtensions",
-  "noPager",
-  "path",
-  "pmExecutable",
-  "timeoutMs"
-];
-var PM_TOOL_ACTION_MUTATION_PARAMETER_KEYS = {
-  create: ["fullChangedFields", "idOnly"],
-  copy: ["fullChangedFields", "idOnly"],
-  update: ["fullChangedFields", "idOnly"],
-  close: ["fullChangedFields", "idOnly"],
-  append: ["fullChangedFields"],
-  "update-many": ["fullChangedFields"],
-  "close-many": ["fullChangedFields"]
-};
-function toSchemaKeyList(values) {
-  return normalizeUniqueStringList(values);
-}
-var CREATE_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_CREATE_OPTION_CONTRACTS.map((entry) => entry.param),
-  ...TOOL_SHARED_CREATE_UPDATE_OPTION_CONTRACTS.map((entry) => entry.param),
-  "assignee"
-]);
-var UPDATE_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_UPDATE_OPTION_CONTRACTS.map((entry) => entry.param),
-  ...TOOL_SHARED_CREATE_UPDATE_OPTION_CONTRACTS.map((entry) => entry.param),
-  "force"
-]);
-var UPDATE_MANY_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_UPDATE_MANY_FILTER_OPTION_CONTRACTS.map((entry) => entry.param),
-  ...UPDATE_CONTRACT_PARAMETER_KEYS,
-  "dryRun",
-  "rollback",
-  "noCheckpoint"
-]);
-var NORMALIZE_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_NORMALIZE_FILTER_OPTION_CONTRACTS.map((entry) => entry.param),
-  "dryRun",
-  "apply",
-  "author",
-  "message",
-  "allowAuditUpdate",
-  "force"
-]);
-var CLOSE_MANY_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_CLOSE_MANY_FILTER_OPTION_CONTRACTS.map((entry) => entry.param),
-  "reason",
-  "resolution",
-  "expectedResult",
-  "actualResult",
-  "validateClose",
-  "dryRun",
-  "rollback",
-  "noCheckpoint",
-  "author",
-  "message",
-  "force"
-]);
-var CONTEXT_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_CONTEXT_OPTION_CONTRACTS.map((entry) => entry.param),
-  "past",
-  "section"
-]);
-var ACTIVITY_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_ACTIVITY_OPTION_CONTRACTS.map((entry) => entry.param),
-  "stream"
-]);
-var LIST_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_LIST_FILTER_OPTION_CONTRACTS.map((entry) => entry.param),
-  "includeBody",
-  "noTruncate",
-  "compact",
-  "brief",
-  "full"
-]);
-var AGGREGATE_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  ...TOOL_AGGREGATE_OPTION_CONTRACTS.map((entry) => entry.param),
-  "count",
-  "completion",
-  "includeUnparented"
-]);
-var DEDUPE_AUDIT_CONTRACT_PARAMETER_KEYS = toSchemaKeyList(TOOL_DEDUPE_AUDIT_OPTION_CONTRACTS.map((entry) => entry.param));
-var SEARCH_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  "query",
-  "keywords",
-  "mode",
-  "semantic",
-  "hybrid",
-  "includeLinked",
-  "titleExact",
-  "phraseExact",
-  "highlight",
-  "compact",
-  "full",
-  ...TOOL_SEARCH_FILTER_OPTION_CONTRACTS.map((entry) => entry.param)
-]);
-var NEXT_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
-  "type",
-  "tag",
-  "priority",
-  "assignee",
-  "assigneeFilter",
-  "sprint",
-  "release",
-  "parent",
-  "limit",
-  "blockedLimit",
-  "readyOnly",
-  "format"
-]);
-var AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS = ["author", "message", "force"];
-var MANAGED_EXTENSION_PACKAGE_OPTION_KEYS = [
-  "target",
-  "scope",
-  "github",
-  "ref",
-  "init",
-  "install",
-  "uninstall",
-  "explore",
-  "manage",
-  "describe",
-  "markdown",
-  "output",
-  "reload",
-  "doctor",
-  "catalog",
-  "adopt",
-  "adoptAll",
-  "activate",
-  "deactivate",
-  "runtimeProbe",
-  "fixManagedState",
-  "detail",
-  "trace",
-  "watch",
-  "strictExit",
-  "failOnWarn"
-];
-function managedLifecycleSchemaContracts(prefix) {
-  return {
-    [`${prefix}-init`]: { required: ["target"], optional: ["scope"] },
-    [`${prefix}-install`]: {
-      optional: ["target", "github", "scope", "ref"],
-      anyOfRequired: [["target"], ["github"]]
-    },
-    [`${prefix}-uninstall`]: { required: ["target"], optional: ["scope"] },
-    [`${prefix}-explore`]: { optional: ["scope"] },
-    [`${prefix}-manage`]: { optional: ["scope", "runtimeProbe", "fixManagedState"] },
-    [`${prefix}-describe`]: { optional: ["target", "scope", "markdown", "output"] },
-    [`${prefix}-reload`]: { optional: ["scope", "watch"] },
-    [`${prefix}-doctor`]: { optional: ["scope", "detail", "trace", "fixManagedState", "strictExit", "failOnWarn"] },
-    [`${prefix}-catalog`]: { optional: ["scope", "fields"] },
-    [`${prefix}-adopt`]: { required: ["target"], optional: ["scope", "github", "ref"] },
-    [`${prefix}-adopt-all`]: { optional: ["scope"] },
-    [`${prefix}-activate`]: { required: ["target"], optional: ["scope"] },
-    [`${prefix}-deactivate`]: { required: ["target"], optional: ["scope"] },
-    [prefix]: {
-      optional: MANAGED_EXTENSION_PACKAGE_OPTION_KEYS
-    }
-  };
-}
-var PM_TOOL_ACTION_SCHEMA_CONTRACTS = {
-  init: { optional: ["prefix", "preset", "typePreset", "defaults", "author", "agentGuidance", "withPackages", "force", "verbose"] },
-  config: {
-    required: ["scope", "configAction"],
-    optional: ["key", "value", "criterion", "clearCriteria", "format", "policy"]
-  },
-  ...managedLifecycleSchemaContracts("extension"),
-  ...managedLifecycleSchemaContracts("package"),
-  install: {
-    optional: ["target", "github", "scope", "ref"],
-    anyOfRequired: [["target"], ["github"]]
-  },
-  upgrade: {
-    optional: ["target", "scope", "dryRun", "cliOnly", "packagesOnly", "repair", "tag", "packageName"]
-  },
-  create: {
-    required: ["title", "description", "type", "status", "priority", "message"],
-    optional: CREATE_CONTRACT_PARAMETER_KEYS
-  },
-  copy: { required: ["id"], optional: ["title", "author", "message"] },
-  focus: { optional: ["id", "clear"], mutuallyExclusive: [["id", "clear"]] },
-  list: { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-all": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-draft": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-open": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-in-progress": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-blocked": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-closed": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  "list-canceled": { optional: LIST_CONTRACT_PARAMETER_KEYS },
-  aggregate: { optional: AGGREGATE_CONTRACT_PARAMETER_KEYS },
-  "dedupe-audit": { optional: DEDUPE_AUDIT_CONTRACT_PARAMETER_KEYS },
-  guide: { optional: ["list", "format", "depth"] },
-  context: { optional: CONTEXT_CONTRACT_PARAMETER_KEYS },
-  ctx: { optional: CONTEXT_CONTRACT_PARAMETER_KEYS },
-  get: { required: ["id"], optional: ["depth", "full", "fields", "tree", "treeDepth", "format"] },
-  search: {
-    optional: SEARCH_CONTRACT_PARAMETER_KEYS,
-    anyOfRequired: [["query"], ["keywords"]]
-  },
-  next: { optional: NEXT_CONTRACT_PARAMETER_KEYS },
-  reindex: { optional: ["mode", "progress"] },
-  history: { required: ["id"], optional: ["limit", "compact", "full", "diff", "verify", "format"] },
-  "history-redact": {
-    required: ["id"],
-    optional: ["literal", "regex", "replacement", "dryRun", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS],
-    anyOfRequired: [["literal"], ["regex"]]
-  },
-  "history-repair": {
-    // Exactly one of `id` (single stream) or `all` (bulk drift repair) is required.
-    optional: ["id", "all", "dryRun", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS],
-    oneOfRequired: [["id"], ["all"]]
-  },
-  "history-compact": {
-    // Single-id mode (`id` + optional `before`) or bulk mode (any of `ids` /
-    // `allOver` / `closed` / `allStreams`, with optional `minEntries`). Scan
-    // selectors (`allOver` + `closed`/`allStreams`) legitimately combine, so the
-    // mode/exclusivity contract is enforced at runtime by assertHistoryCompactTarget
-    // rather than a one-of schema rule.
-    optional: ["id", "before", "ids", "allOver", "closed", "allStreams", "minEntries", "dryRun", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS]
-  },
-  schema: {
-    required: ["subcommand"],
-    // No --message: schema mutations write config files, not item history.
-    optional: [
-      "name",
-      "description",
-      "defaultStatus",
-      "folder",
-      "alias",
-      "role",
-      "order",
-      "fieldType",
-      "commands",
-      "cliFlag",
-      "required",
-      "requiredOnCreate",
-      "allowUnset",
-      "requiredTypes",
-      "typePreset",
-      "infer",
-      "minCount",
-      "apply",
-      "author",
-      "force"
-    ],
-    conditionalRequired: [
-      { property: "subcommand", value: "show", required: ["name"] },
-      { property: "subcommand", value: "show-status", required: ["name"] },
-      { property: "subcommand", value: "add-type", required: ["name"] },
-      { property: "subcommand", value: "remove-type", required: ["name"] },
-      // show-status/add-status/remove-status pass the status id as `name`.
-      { property: "subcommand", value: "add-status", required: ["name"] },
-      { property: "subcommand", value: "remove-status", required: ["name"] },
-      // field subcommands pass the field key as `name`.
-      { property: "subcommand", value: "add-field", required: ["name"] },
-      { property: "subcommand", value: "remove-field", required: ["name"] },
-      { property: "subcommand", value: "show-field", required: ["name"] },
-      // apply-preset passes the preset name as `typePreset`.
-      { property: "subcommand", value: "apply-preset", required: ["typePreset"] }
-    ]
-  },
-  profile: {
-    required: ["subcommand"],
-    // No --message: profile staging writes config/schema files, not item history.
-    optional: ["name", "dryRun", "author", "force"],
-    conditionalRequired: [
-      { property: "subcommand", value: "show", required: ["name"] },
-      { property: "subcommand", value: "apply", required: ["name"] },
-      { property: "subcommand", value: "lint", required: ["name"] }
-    ]
-  },
-  plan: {
-    required: ["subcommand"],
-    optional: [
-      "id",
-      "stepRef",
-      "reorderTo",
-      "title",
-      "description",
-      "scope",
-      "parent",
-      "related",
-      "blocks",
-      "blockedBy",
-      "harness",
-      "mode",
-      "resumeContext",
-      "tags",
-      "priority",
-      "body",
-      "claim",
-      "fromSearch",
-      "stepTitle",
-      "step",
-      "stepBody",
-      "stepOwner",
-      "stepStatus",
-      "stepEvidence",
-      "stepBlockedReason",
-      "stepReplacement",
-      "dependsOn",
-      "link",
-      "linkKind",
-      "linkNote",
-      "promoteToItemDep",
-      "allowMultipleActive",
-      "file",
-      "test",
-      "doc",
-      "decisionText",
-      "decision",
-      "decisionRationale",
-      "decisionEvidence",
-      "discoveryText",
-      "discovery",
-      "validationText",
-      "validation",
-      "validationCommand",
-      "validationExpected",
-      "depth",
-      "fields",
-      "steps",
-      "materializeType",
-      "materializeParent",
-      "materializeTags",
-      ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS
-    ]
-  },
-  activity: { optional: ACTIVITY_CONTRACT_PARAMETER_KEYS },
-  restore: { required: ["id", "target"], optional: AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS },
-  update: { required: ["id"], optional: UPDATE_CONTRACT_PARAMETER_KEYS },
-  "update-many": { optional: UPDATE_MANY_CONTRACT_PARAMETER_KEYS },
-  normalize: { optional: NORMALIZE_CONTRACT_PARAMETER_KEYS },
-  close: {
-    required: ["id"],
-    optional: [
-      "text",
-      "reason",
-      "closeReason",
-      "duplicateOf",
-      "validateClose",
-      "resolution",
-      "expectedResult",
-      "actualResult",
-      ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS
-    ]
-  },
-  "close-many": { optional: CLOSE_MANY_CONTRACT_PARAMETER_KEYS },
-  delete: { required: ["id"], optional: ["dryRun", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS] },
-  append: { required: ["id", "body"], optional: AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS },
-  comments: {
-    required: ["id"],
-    optional: ["text", "add", "stdin", "file", "edit", "delete", "limit", "allowAuditComment", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS]
-  },
-  "comments-audit": {
-    optional: [
-      "status",
-      "type",
-      "assignee",
-      "assigneeFilter",
-      "parent",
-      "tag",
-      "sprint",
-      "release",
-      "priority",
-      "limitItems",
-      "limit",
-      "fullHistory",
-      "latest"
-    ]
-  },
-  notes: {
-    required: ["id"],
-    optional: ["text", "add", "limit", "allowAuditNote", "allowAuditComment", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS]
-  },
-  learnings: {
-    required: ["id"],
-    optional: ["text", "add", "limit", "allowAuditLearning", "allowAuditComment", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS]
-  },
-  files: {
-    required: ["id"],
-    optional: [
-      "add",
-      "addGlob",
-      "remove",
-      "migrate",
-      "list",
-      // GH-170 (pm-pfnx): `addNote` is the MCP spelling of the CLI --note flag
-      // (the shared `note` parameter is the array-typed create/update note
-      // seed, so files/docs use a distinct single-string key).
-      "addNote",
-      "discover",
-      "apply",
-      "discoveryNote",
-      "appendStable",
-      "validatePaths",
-      "audit",
-      ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS
-    ],
-    dependentAnyOfRequired: [{ property: "addNote", anyOfRequired: [["add"], ["addGlob"]] }]
-  },
-  docs: {
-    required: ["id"],
-    optional: [
-      "add",
-      "addGlob",
-      "remove",
-      "migrate",
-      "addNote",
-      "list",
-      "validatePaths",
-      "audit",
-      ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS
-    ],
-    dependentAnyOfRequired: [{ property: "addNote", anyOfRequired: [["add"], ["addGlob"]] }]
-  },
-  deps: { required: ["id"], optional: ["format", "maxDepth", "collapse", "summary"] },
-  test: {
-    required: ["id"],
-    optional: [
-      "add",
-      "addJson",
-      "remove",
-      "run",
-      "match",
-      "onlyIndex",
-      "onlyLast",
-      "background",
-      "timeout",
-      "progress",
-      "envSet",
-      "envClear",
-      "sharedHostSafe",
-      "pmContext",
-      "overrideLinkedPmContext",
-      "failOnContextMismatch",
-      "failOnSkipped",
-      "failOnEmptyTestRun",
-      "requireAssertionsForPm",
-      "checkContext",
-      "autoPmContext",
-      ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS
-    ]
-  },
-  "test-all": {
-    optional: [
-      "status",
-      "limit",
-      "offset",
-      "background",
-      "timeout",
-      "progress",
-      "envSet",
-      "envClear",
-      "sharedHostSafe",
-      "pmContext",
-      "overrideLinkedPmContext",
-      "failOnContextMismatch",
-      "failOnSkipped",
-      "failOnEmptyTestRun",
-      "requireAssertionsForPm",
-      "checkContext",
-      "autoPmContext"
-    ]
-  },
-  telemetry: {
-    optional: ["subcommand", "limit"]
-  },
-  "test-runs-list": {
-    optional: ["status", "limit"]
-  },
-  "test-runs-status": {
-    required: ["runId"]
-  },
-  "test-runs-logs": {
-    required: ["runId"],
-    optional: ["stream", "tail"]
-  },
-  "test-runs-stop": {
-    required: ["runId"],
-    optional: ["force"]
-  },
-  "test-runs-resume": {
-    required: ["runId"],
-    optional: ["author"]
-  },
-  stats: { optional: ["storage", "metadataCoverage", "fieldUtilization", "byAssignee", "byTag", "byPriority", "tagPrefix"] },
-  health: {
-    optional: [
-      "strictDirectories",
-      "strictExit",
-      "failOnWarn",
-      "checkOnly",
-      "checkTelemetry",
-      "noRefresh",
-      "refreshVectors",
-      "verboseStaleItems",
-      "brief",
-      "summary",
-      "skipVectors",
-      "skipIntegrity",
-      "skipDrift",
-      "full"
-    ]
-  },
-  validate: {
-    optional: [
-      "checkMetadata",
-      "metadataProfile",
-      "checkResolution",
-      "checkLifecycle",
-      "checkStaleBlockers",
-      "dependencyCycleSeverity",
-      "parentCycleSeverity",
-      "checkFiles",
-      "scanMode",
-      "includePmInternals",
-      "verboseFileLists",
-      "verboseDiagnostics",
-      "allAffectedIds",
-      "strictExit",
-      "failOnWarn",
-      "fixHints",
-      "autoFix",
-      "dryRun",
-      "fixScope",
-      "pruneMissing",
-      "checkHistoryDrift",
-      "checkCommandReferences"
-    ]
-  },
-  gc: { optional: ["dryRun", "gcScope"] },
-  contracts: { optional: ["contractAction", "command", "schemaOnly", "flagsOnly", "availabilityOnly", "runtimeOnly", "activeOnly", "full"] },
-  completion: { required: ["shell"], optional: ["eagerTags"] },
-  claim: { required: ["id"], optional: AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS },
-  release: { required: ["id"], optional: ["allowAuditRelease", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS] },
-  "start-task": { required: ["id"], optional: AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS },
-  "pause-task": { required: ["id"], optional: AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS },
-  "close-task": { required: ["id"], optional: ["text", "validateClose", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS] }
-};
-var PM_TOOL_ACTION_PARAMETER_CONTRACTS = Object.freeze(Object.fromEntries(PM_TOOL_ACTIONS.map((action) => [action, PM_TOOL_ACTION_SCHEMA_CONTRACTS[action]])));
-function fallbackToolParameterDescription(key) {
-  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").trim().replace(/^./, (value) => value.toUpperCase()).concat(".");
-}
-function decorateToolParameterDefinition(key, definition) {
-  const baseDefinition = typeof definition === "object" && definition !== null ? { ...definition } : {};
-  const metadata = PM_TOOL_PARAMETER_METADATA[key];
-  return {
-    ...baseDefinition,
-    description: metadata?.description ?? fallbackToolParameterDescription(key),
-    ...metadata?.examples ? { examples: metadata.examples } : {}
-  };
-}
-function actionScopedToolParameterMetadata(action, key) {
-  if (action === "plan" && Object.prototype.hasOwnProperty.call(PLAN_ACTION_PARAMETER_METADATA, key)) {
-    return PLAN_ACTION_PARAMETER_METADATA[key];
-  }
-  const actionOverrides = PM_TOOL_ACTION_SCOPED_PARAMETER_METADATA[action];
-  if (actionOverrides && Object.prototype.hasOwnProperty.call(actionOverrides, key)) {
-    return actionOverrides[key];
-  }
-  return PM_TOOL_PARAMETER_METADATA[key];
-}
-function decorateActionScopedToolParameterDefinition(action, key, definition) {
-  const baseDefinition = typeof definition === "object" && definition !== null ? { ...definition } : {};
-  const metadata = actionScopedToolParameterMetadata(action, key);
-  return {
-    ...baseDefinition,
-    description: metadata?.description ?? fallbackToolParameterDescription(key),
-    ...metadata?.examples ? { examples: metadata.examples } : {}
-  };
-}
-function actionScopedToolParameterDefinition(action, key) {
-  if (action === "plan" && Object.prototype.hasOwnProperty.call(PLAN_ACTION_PARAMETER_PROPERTIES, key)) {
-    return PLAN_ACTION_PARAMETER_PROPERTIES[key];
-  }
-  if ((action === "get" || action === "history" || action === "search") && key === "format") {
-    return { type: "string", enum: ["json", "toon"] };
-  }
-  return PM_TOOL_PARAMETER_PROPERTIES[key];
-}
-function buildActionScopedSchemaProperties(action, allowedKeys) {
-  const properties = {
-    action: {
-      const: action,
-      description: PM_TOOL_PARAMETER_METADATA.action?.description ?? "Tool action to execute."
-    }
-  };
-  for (const key of allowedKeys) {
-    if (key === "action") {
-      continue;
-    }
-    const definition = actionScopedToolParameterDefinition(action, key);
-    if (definition) {
-      properties[key] = decorateActionScopedToolParameterDefinition(action, key, definition);
-    }
-  }
-  return properties;
-}
-function buildOneOfSchemaEntries(action, oneOfRequiredGroups) {
-  const allOneOfFields = oneOfRequiredGroups.flat();
-  return oneOfRequiredGroups.map((requiredFields) => {
-    const otherFields = allOneOfFields.filter((field) => !requiredFields.includes(field));
-    return {
-      required: [...requiredFields],
-      ...otherFields.length > 0 ? { not: { anyOf: otherFields.map((field) => ({ required: [field] })) } } : {},
-      ...action === "history-repair" && requiredFields.includes("all") ? { properties: { all: { const: true } } } : {}
-    };
-  });
-}
-function buildActionScopedAllOf(contract) {
-  const allOf = [];
-  if (contract.conditionalRequired && contract.conditionalRequired.length > 0) {
-    for (const entry of contract.conditionalRequired) {
-      allOf.push({
-        if: {
-          properties: {
-            [entry.property]: { const: entry.value }
-          },
-          required: [entry.property]
-        },
-        // eslint-disable-next-line unicorn/no-thenable -- JSON Schema conditional keyword, not a Promise-like object.
-        then: {
-          required: entry.required
-        }
-      });
-    }
-  }
-  if (contract.dependentAnyOfRequired && contract.dependentAnyOfRequired.length > 0) {
-    for (const entry of contract.dependentAnyOfRequired) {
-      allOf.push({
-        if: { required: [entry.property] },
-        // eslint-disable-next-line unicorn/no-thenable -- JSON Schema conditional keyword, not a Promise-like object.
-        then: {
-          anyOf: entry.anyOfRequired.map((requiredFields) => ({
-            required: [...requiredFields]
-          }))
-        }
-      });
-    }
-  }
-  if (contract.mutuallyExclusive && contract.mutuallyExclusive.length > 0) {
-    for (const group of contract.mutuallyExclusive) {
-      allOf.push({ not: { required: toSchemaKeyList(group) } });
-    }
-  }
-  return allOf;
-}
-function buildActionScopedToolSchema(action) {
-  const contract = PM_TOOL_ACTION_SCHEMA_CONTRACTS[action];
-  const required = toSchemaKeyList(contract.required ?? []);
-  const optional = toSchemaKeyList(contract.optional ?? []);
-  const mutationParameterKeys = PM_TOOL_ACTION_MUTATION_PARAMETER_KEYS[action] ?? [];
-  const allowedKeys = toSchemaKeyList(["action", ...PM_TOOL_GLOBAL_PARAMETER_KEYS, ...mutationParameterKeys, ...required, ...optional]);
-  const schema = {
-    type: "object",
-    additionalProperties: false,
-    required: ["action", ...required],
-    title: `pm action "${action}" parameters`,
-    properties: buildActionScopedSchemaProperties(action, allowedKeys)
-  };
-  if (contract.anyOfRequired && contract.anyOfRequired.length > 0) {
-    schema.anyOf = contract.anyOfRequired.map((requiredFields) => ({
-      required: [...requiredFields]
-    }));
-  }
-  if (contract.oneOfRequired && contract.oneOfRequired.length > 0) {
-    schema.oneOf = buildOneOfSchemaEntries(action, contract.oneOfRequired);
-  }
-  const allOf = buildActionScopedAllOf(contract);
-  if (allOf.length > 0) {
-    schema.allOf = allOf;
-  }
-  return schema;
-}
-function createLazyContractSchema(build) {
-  let value;
-  const resolve = () => value ??= build();
-  return new Proxy({}, {
-    get: (_target, prop) => resolve()[prop],
-    has: (_target, prop) => prop in resolve(),
-    ownKeys: () => Reflect.ownKeys(resolve()),
-    getOwnPropertyDescriptor: (_target, prop) => {
-      const descriptor = Reflect.getOwnPropertyDescriptor(resolve(), prop);
-      if (descriptor) {
-        descriptor.configurable = true;
-      }
-      return descriptor;
-    }
-  });
-}
-var PM_TOOL_PARAMETERS_SCHEMA_VERSION = "4.0.6";
-var PM_TOOL_PARAMETERS_SCHEMA_MAJOR = PM_TOOL_PARAMETERS_SCHEMA_VERSION.split(".")[0];
-var PM_PROVIDER_TOOL_PARAMETERS_SCHEMA_VERSION = "1.0.0";
-var PM_TOOL_PARAMETERS_SCHEMA = createLazyContractSchema(() => ({
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: `https://schema.unbrained.dev/pm-cli/tool-parameters-v${PM_TOOL_PARAMETERS_SCHEMA_MAJOR}.schema.json`,
-  title: "pm-cli tool parameters (action-scoped strict schema)",
-  "x-schema-version": PM_TOOL_PARAMETERS_SCHEMA_VERSION,
-  type: "object",
-  oneOf: PM_TOOL_ACTIONS.map((action) => buildActionScopedToolSchema(action))
-}));
-function toProviderCompatibleParameterDefinition(key, definition) {
-  const decorated = decorateToolParameterDefinition(key, definition);
-  if (typeof decorated.type === "string") {
-    return decorated;
-  }
-  const anyOf = Array.isArray(decorated.anyOf) ? decorated.anyOf : [];
-  const firstTypedVariant = anyOf.find((variant) => typeof variant.type === "string");
-  if (firstTypedVariant) {
-    const { anyOf: _anyOf2, ...rest2 } = decorated;
-    return {
-      ...firstTypedVariant,
-      ...rest2
-    };
-  }
-  const { anyOf: _anyOf, ...rest } = decorated;
-  return {
-    ...rest,
-    type: "string"
-  };
-}
-function buildProviderCompatibleToolSchema() {
-  const properties = {
-    action: {
-      type: "string",
-      description: PM_TOOL_PARAMETER_METADATA.action?.description ?? "Tool action to execute."
-    },
-    options: {
-      type: "object",
-      additionalProperties: true,
-      description: "Advanced command options object forwarded to the selected pm action."
-    }
-  };
-  for (const key of Object.keys(PM_TOOL_PARAMETER_PROPERTIES).sort()) {
-    properties[key] = toProviderCompatibleParameterDefinition(key, PM_TOOL_PARAMETER_PROPERTIES[key]);
-  }
-  return {
-    title: "pm-cli tool parameters (provider-compatible flat schema)",
-    "x-schema-version": PM_PROVIDER_TOOL_PARAMETERS_SCHEMA_VERSION,
-    type: "object",
-    additionalProperties: false,
-    required: ["action"],
-    properties
-  };
-}
-var PM_PROVIDER_TOOL_PARAMETERS_SCHEMA = createLazyContractSchema(buildProviderCompatibleToolSchema);
-var _testOnlyCliContracts = {
-  buildActionScopedToolSchema,
-  buildProviderCompatibleToolSchema,
-  decorateActionScopedToolParameterDefinition,
-  decorateToolParameterDefinition,
-  toolActionSchemaContracts: PM_TOOL_ACTION_SCHEMA_CONTRACTS,
-  toolParameterMetadata: PM_TOOL_PARAMETER_METADATA,
-  toProviderCompatibleParameterDefinition,
-  toUniqueFlagContracts,
-  withFlagAliasMetadata
-};
-
-// dist/sdk/cli-contracts.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] = "b8aa5310-bff0-59b5-9a34-c6fc6a46582d");
-  } catch (e2) {
-  }
-})();
-
-export {
-  LIST_COMMANDER_STRING_OPTION_CONTRACTS,
-  SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
-  CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS,
-  CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
-  NEXT_COMMANDER_STRING_OPTION_CONTRACTS,
-  ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
-  readFirstStringFromCommanderOptions,
-  readFirstValueFromCommanderOptions,
-  readStringArrayFromCommanderOptions,
-  CREATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS,
-  CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
-  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
-  UPDATE_COMMANDER_OPTION_REGISTRATION_CONTRACTS,
-  UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
-  UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
-  PM_EXTENSION_CAPABILITY_CONTRACTS,
-  PM_EXTENSION_SERVICE_NAME_CONTRACTS,
-  PM_EXTENSION_POLICY_MODE_CONTRACTS,
-  PM_EXTENSION_TRUST_MODE_CONTRACTS,
-  PM_EXTENSION_SANDBOX_PROFILE_CONTRACTS,
-  PM_EXTENSION_POLICY_SURFACE_CONTRACTS,
-  PM_CORE_COMMAND_NAMES,
-  PM_TOOL_ACTIONS,
-  isPmToolAction,
-  isPmExtensionCapabilityContract,
-  isPmExtensionServiceNameContract,
-  isPmExtensionPolicyModeContract,
-  isPmExtensionPolicySurfaceContract,
-  TOOL_LIST_FILTER_OPTION_CONTRACTS,
-  TOOL_AGGREGATE_OPTION_CONTRACTS,
-  TOOL_DEDUPE_AUDIT_OPTION_CONTRACTS,
-  TOOL_SEARCH_FILTER_OPTION_CONTRACTS,
-  TOOL_SHARED_CREATE_UPDATE_OPTION_CONTRACTS,
-  TOOL_CREATE_OPTION_CONTRACTS,
-  TOOL_UPDATE_OPTION_CONTRACTS,
-  TOOL_UPDATE_MANY_FILTER_OPTION_CONTRACTS,
-  TOOL_NORMALIZE_FILTER_OPTION_CONTRACTS,
-  TOOL_CLOSE_MANY_FILTER_OPTION_CONTRACTS,
-  TOOL_CALENDAR_OPTION_CONTRACTS,
-  TOOL_ACTIVITY_OPTION_CONTRACTS,
-  TOOL_CONTEXT_OPTION_CONTRACTS,
-  TOOL_DEPS_OPTION_CONTRACTS,
-  withFlagAliasMetadata,
-  compactFlagAliasContracts,
-  SUBCOMMAND_GLOBAL_FLAG_CONTRACTS,
-  GLOBAL_FLAG_CONTRACTS,
-  LIST_FILTER_FLAG_CONTRACTS,
-  AGGREGATE_FLAG_CONTRACTS,
-  DEDUPE_AUDIT_FLAG_CONTRACTS,
-  DEDUPE_MERGE_FLAG_CONTRACTS,
-  COMMENTS_AUDIT_FLAG_CONTRACTS,
-  COMMENTS_FLAG_CONTRACTS,
-  NOTES_FLAG_CONTRACTS,
-  LEARNINGS_FLAG_CONTRACTS,
-  FILES_FLAG_CONTRACTS,
-  DOCS_FLAG_CONTRACTS,
-  HISTORY_FLAG_CONTRACTS,
-  HISTORY_REDACT_FLAG_CONTRACTS,
-  HISTORY_REPAIR_FLAG_CONTRACTS,
-  HISTORY_COMPACT_FLAG_CONTRACTS,
-  SCHEMA_FLAG_CONTRACTS,
-  PROFILE_FLAG_CONTRACTS,
-  PLAN_FLAG_CONTRACTS,
-  INIT_FLAG_CONTRACTS,
-  CONFIG_FLAG_CONTRACTS,
-  EXTENSION_FLAG_CONTRACTS,
-  EXTENSION_SCOPE_FLAG_CONTRACTS,
-  EXTENSION_INIT_FLAG_CONTRACTS,
-  PACKAGE_FLAG_CONTRACTS,
-  PACKAGE_INIT_FLAG_CONTRACTS,
-  EXTENSION_INSTALL_FLAG_CONTRACTS,
-  EXTENSION_UNINSTALL_FLAG_CONTRACTS,
-  EXTENSION_EXPLORE_FLAG_CONTRACTS,
-  EXTENSION_DESCRIBE_FLAG_CONTRACTS,
-  EXTENSION_ADOPT_ALL_FLAG_CONTRACTS,
-  EXTENSION_ACTIVATE_FLAG_CONTRACTS,
-  EXTENSION_DEACTIVATE_FLAG_CONTRACTS,
-  EXTENSION_MANAGE_FLAG_CONTRACTS,
-  EXTENSION_RELOAD_FLAG_CONTRACTS,
-  EXTENSION_DOCTOR_FLAG_CONTRACTS,
-  EXTENSION_CATALOG_FLAG_CONTRACTS,
-  EXTENSION_ADOPT_FLAG_CONTRACTS,
-  INSTALL_FLAG_CONTRACTS,
-  UPGRADE_FLAG_CONTRACTS,
-  REINDEX_FLAG_CONTRACTS,
-  CLOSE_FLAG_CONTRACTS,
-  CLOSE_MANY_FLAG_CONTRACTS,
-  APPEND_FLAG_CONTRACTS,
-  CLAIM_FLAG_CONTRACTS,
-  RESTORE_FLAG_CONTRACTS,
-  DELETE_FLAG_CONTRACTS,
-  RELEASE_FLAG_CONTRACTS,
-  START_TASK_FLAG_CONTRACTS,
-  PAUSE_TASK_FLAG_CONTRACTS,
-  CLOSE_TASK_FLAG_CONTRACTS,
-  MEET_FLAG_CONTRACTS,
-  EVENT_FLAG_CONTRACTS,
-  REMIND_FLAG_CONTRACTS,
-  TEST_FLAG_CONTRACTS,
-  TEST_ALL_FLAG_CONTRACTS,
-  TELEMETRY_FLAG_CONTRACTS,
-  TEST_RUNS_FLAG_CONTRACTS,
-  GC_FLAG_CONTRACTS,
-  STATS_FLAG_CONTRACTS,
-  HEALTH_FLAG_CONTRACTS,
-  VALIDATE_FLAG_CONTRACTS,
-  CREATE_FLAG_CONTRACTS,
-  COPY_FLAG_CONTRACTS,
-  FOCUS_FLAG_CONTRACTS,
-  UPDATE_FLAG_CONTRACTS,
-  UPDATE_MANY_FLAG_CONTRACTS,
-  NORMALIZE_FLAG_CONTRACTS,
-  CALENDAR_FLAG_CONTRACTS,
-  ACTIVITY_FLAG_CONTRACTS,
-  CONTEXT_FLAG_CONTRACTS,
-  GET_FLAG_CONTRACTS,
-  GUIDE_FLAG_CONTRACTS,
-  DEPS_FLAG_CONTRACTS,
-  EVAL_FLAG_CONTRACTS,
-  NEXT_FLAG_CONTRACTS,
-  SEARCH_FLAG_CONTRACTS,
-  CONTRACTS_FLAG_CONTRACTS,
-  COMPLETION_FLAG_CONTRACTS,
-  resolveSubcommandFlagContractsForCommand,
-  toCompletionFlagString,
-  PM_TOOL_ACTION_PARAMETER_CONTRACTS,
-  PM_TOOL_PARAMETERS_SCHEMA_VERSION,
-  PM_TOOL_PARAMETERS_SCHEMA_MAJOR,
-  PM_PROVIDER_TOOL_PARAMETERS_SCHEMA_VERSION,
-  PM_TOOL_PARAMETERS_SCHEMA,
-  PM_PROVIDER_TOOL_PARAMETERS_SCHEMA,
-  _testOnlyCliContracts
-};
-//# sourceMappingURL=chunk-UI5BJ6DO.js.map