@unbrained/pm-cli 2026.5.30 → 2026.5.31

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

@@ -0,0 +1,3621 @@
+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-LSXGH6NE.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] = "5b919cb4-d842-52b2-92f8-d07fb6637a19");
+  } catch (e2) {
+  }
+})();
+var LIST_COMMANDER_STRING_OPTION_CONTRACTS = [
+  { target: "status", keys: ["status"] },
+  { target: "type", keys: ["type"] },
+  { target: "tag", keys: ["tag"] },
+  { target: "priority", keys: ["priority"] },
+  { target: "deadlineBefore", keys: ["deadlineBefore"] },
+  { target: "deadlineAfter", keys: ["deadlineAfter"] },
+  { 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"] }
+];
+var SEARCH_COMMANDER_STRING_OPTION_CONTRACTS = [
+  { target: "mode", keys: ["mode"] },
+  { target: "type", keys: ["type"] },
+  { target: "tag", keys: ["tag"] },
+  { target: "priority", keys: ["priority"] },
+  { target: "deadlineBefore", keys: ["deadlineBefore"] },
+  { target: "deadlineAfter", keys: ["deadlineAfter"] },
+  { 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: "limit", keys: ["limit"] },
+  { target: "format", keys: ["format"] },
+  { target: "depth", keys: ["depth"] },
+  { target: "activityLimit", keys: ["activityLimit", "activity_limit"] },
+  { target: "staleThreshold", keys: ["staleThreshold", "stale_threshold"] }
+];
+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 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] = "8f0d6f98-ad14-5cd7-aea8-a43737f51032");
+  } 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: "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: "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: "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>,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>,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: "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] = "e93f5c1f-0703-5c95-b7b8-84264cf9ed1f");
+  } 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",
+  "list",
+  "list-all",
+  "list-draft",
+  "list-open",
+  "list-in-progress",
+  "list-blocked",
+  "list-closed",
+  "list-canceled",
+  "aggregate",
+  "context",
+  "ctx",
+  "get",
+  "search",
+  "history",
+  "history-redact",
+  "history-repair",
+  "schema",
+  "activity",
+  "restore",
+  "update",
+  "update-many",
+  "close",
+  "delete",
+  "append",
+  "comments",
+  "notes",
+  "learnings",
+  "files",
+  "docs",
+  "deps",
+  "plan",
+  "test",
+  "test-all",
+  "stats",
+  "health",
+  "validate",
+  "gc",
+  "contracts",
+  "claim",
+  "release",
+  "start-task",
+  "pause-task",
+  "close-task",
+  "help"
+];
+var PM_TOOL_ACTIONS = [
+  "init",
+  "config",
+  "extension-init",
+  "extension-install",
+  "extension-uninstall",
+  "extension-explore",
+  "extension-manage",
+  "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-reload",
+  "package-doctor",
+  "package-catalog",
+  "package-adopt",
+  "package-adopt-all",
+  "package-activate",
+  "package-deactivate",
+  "package",
+  "install",
+  "upgrade",
+  "create",
+  "list",
+  "list-all",
+  "list-draft",
+  "list-open",
+  "list-in-progress",
+  "list-blocked",
+  "list-closed",
+  "list-canceled",
+  "aggregate",
+  "context",
+  "ctx",
+  "get",
+  "search",
+  "history",
+  "history-redact",
+  "history-repair",
+  "schema",
+  "activity",
+  "restore",
+  "update",
+  "update-many",
+  "close",
+  "delete",
+  "append",
+  "comments",
+  "plan",
+  "notes",
+  "learnings",
+  "files",
+  "docs",
+  "deps",
+  "test",
+  "test-all",
+  "stats",
+  "health",
+  "validate",
+  "gc",
+  "contracts",
+  "claim",
+  "release",
+  "start-task",
+  "pause-task",
+  "close-task"
+];
+
+// 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] = "f77c9493-e7b2-5549-a205-1b67dc69700e");
+  } catch (e2) {
+  }
+})();
+var TOOL_LIST_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" },
+  { param: "assignee", flag: "--assignee" },
+  { param: "assigneeFilter", flag: "--assignee-filter" },
+  { param: "parent", flag: "--parent" },
+  { param: "sprint", flag: "--sprint" },
+  { param: "release", flag: "--release" },
+  { param: "limit", flag: "--limit" },
+  { param: "offset", flag: "--offset" },
+  { param: "fields", flag: "--fields" },
+  { param: "sort", flag: "--sort" },
+  { param: "order", flag: "--order" }
+];
+var TOOL_AGGREGATE_OPTION_CONTRACTS = [
+  { param: "groupBy", flag: "--group-by" },
+  { 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" },
+  { param: "assignee", flag: "--assignee" },
+  { param: "assigneeFilter", flag: "--assignee-filter" },
+  { param: "parent", flag: "--parent" },
+  { param: "sprint", flag: "--sprint" },
+  { param: "release", flag: "--release" }
+];
+var TOOL_DEDUPE_AUDIT_OPTION_CONTRACTS = [
+  { param: "mode", flag: "--mode" },
+  { param: "limit", flag: "--limit" },
+  { param: "threshold", flag: "--threshold" },
+  { 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" },
+  { param: "assignee", flag: "--assignee" },
+  { param: "assigneeFilter", flag: "--assignee-filter" },
+  { param: "parent", flag: "--parent" },
+  { param: "sprint", flag: "--sprint" },
+  { param: "release", flag: "--release" }
+];
+var TOOL_SEARCH_FILTER_OPTION_CONTRACTS = [
+  { param: "type", flag: "--type" },
+  { param: "tag", flag: "--tag" },
+  { param: "priority", flag: "--priority" },
+  { param: "deadlineBefore", flag: "--deadline-before" },
+  { param: "deadlineAfter", flag: "--deadline-after" },
+  { 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: "reminder", flag: "--reminder", repeatable: true },
+  { param: "event", flag: "--event", repeatable: true },
+  { param: "typeOption", flag: "--type-option", 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: "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_UPDATE_MANY_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_NORMALIZE_FILTER_OPTION_CONTRACTS = [...TOOL_UPDATE_MANY_FILTER_OPTION_CONTRACTS];
+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: "limit", flag: "--limit" },
+  { param: "format", flag: "--format" },
+  { param: "depth", flag: "--depth" },
+  { param: "section", flag: "--section", repeatable: true },
+  { param: "activityLimit", flag: "--activity-limit" },
+  { param: "staleThreshold", flag: "--stale-threshold" }
+];
+
+// 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] = "09eef83c-817b-5d26-8f58-016e2c7c39ad");
+  } 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" },
+  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"] },
+  defaults: { type: "boolean" },
+  agentGuidance: { type: "string", enum: ["ask", "add", "skip", "status"] },
+  withPackages: { type: "boolean" },
+  scope: { type: "string", enum: ["project", "global"] },
+  contractAction: { type: "string" },
+  command: { type: "string" },
+  schemaOnly: { type: "boolean" },
+  flagsOnly: { type: "boolean" },
+  availabilityOnly: { type: "boolean" },
+  runtimeOnly: { type: "boolean" },
+  activeOnly: { type: "boolean" },
+  eagerTags: { type: "boolean" },
+  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" },
+  filterAssignee: { type: "string" },
+  filterAssigneeFilter: { type: "string", enum: ["assigned", "unassigned"] },
+  filterParent: { type: "string" },
+  filterSprint: { type: "string" },
+  filterRelease: { type: "string" },
+  closeReason: { 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"]
+  },
+  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" },
+  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" },
+  includeBody: { type: "boolean" },
+  tag: { type: "string" },
+  deadlineBefore: { type: "string" },
+  deadlineAfter: { type: "string" },
+  limit: { anyOf: [{ type: "string" }, { type: "number" }] },
+  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" }] },
+  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" },
+  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"] },
+  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" },
+  scanMode: { type: "string", enum: ["default", "tracked-all", "tracked-all-strict"] },
+  includePmInternals: { type: "boolean" },
+  verboseFileLists: { type: "boolean" },
+  strictExit: { type: "boolean" },
+  failOnWarn: { type: "boolean" },
+  checkHistoryDrift: { type: "boolean" },
+  checkCommandReferences: { type: "boolean" },
+  allowAuditNote: { type: "boolean" },
+  allowAuditLearning: { type: "boolean" },
+  allowAuditComment: { type: "boolean" },
+  allowAuditUpdate: { type: "boolean" },
+  allowAuditDepUpdate: { type: "boolean" },
+  allowAuditRelease: { type: "boolean" },
+  dryRun: { 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" },
+  includeUnparented: { type: "boolean" },
+  gcScope: {
+    type: "array",
+    items: { type: "string", enum: ["index", "embeddings", "runtime"] }
+  },
+  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" } },
+  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" },
+  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" } },
+  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" },
+  threshold: { anyOf: [{ type: "string" }, { type: "number" }] },
+  format: { type: "string" },
+  depth: { type: "string", enum: ["brief", "standard", "deep"] },
+  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" },
+  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"]
+  },
+  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"]
+  },
+  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 for the schema action.",
+    examples: ["add-type"]
+  },
+  name: {
+    description: "Custom item type name to register (for schema add-type).",
+    examples: ["Spike"]
+  },
+  defaultStatus: {
+    description: "Default status hint recorded for a custom item type.",
+    examples: ["open"]
+  },
+  alias: {
+    description: "Aliases for the custom item type (repeatable).",
+    examples: [["spike", "research"]]
+  },
+  preset: {
+    description: "Governance preset for initialization flows.",
+    examples: ["minimal", "default", "strict"]
+  },
+  defaults: {
+    description: "Use non-interactive setup defaults during initialization."
+  },
+  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"]
+  },
+  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"]
+  },
+  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"]
+  },
+  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."
+  },
+  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."
+  },
+  gcScope: {
+    description: "Repeatable gc scope selector values (index, embeddings, runtime).",
+    examples: [["index", "embeddings"], ["runtime"]]
+  },
+  offset: {
+    description: "Number of matching rows to skip before limit is applied.",
+    examples: [0, 50, "100"]
+  },
+  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"]
+  },
+  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."
+  },
+  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."
+  },
+  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: "When true for files discovery, add missing discovered file links instead of returning a dry-run preview."
+  },
+  discoveryNote: {
+    description: "Note attached to file links added by files discovery.",
+    examples: ["discovered from item text"]
+  },
+  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."
+  },
+  includeBody: {
+    description: "When true for list-family actions, include item body text in projected rows."
+  },
+  compact: {
+    description: "Render compact projection output for search and list-family actions."
+  },
+  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, or list-family outputs.",
+    examples: ["id,title,status,parent,type", "id,title,score,matched_fields"]
+  },
+  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."
+  },
+  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).",
+    examples: ["brief", "standard", "deep"]
+  },
+  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"]
+  }
+};
+
+// 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] = "b98193ee-1196-5e27-b732-d15db107a7e4");
+  } catch (e2) {
+  }
+})();
+function normalizeUniqueStringList(values) {
+  return [...new Set(Array.from(values).filter((value) => value.trim().length > 0))];
+}
+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: "--path" },
+  { flag: "--no-extensions" },
+  { flag: "--no-pager" },
+  { flag: "--profile" },
+  { flag: "--help" }
+];
+var GLOBAL_FLAG_CONTRACTS = [
+  ...SUBCOMMAND_GLOBAL_FLAG_CONTRACTS,
+  { flag: "--version" }
+];
+var LIST_FILTER_FLAG_CONTRACTS = [
+  { flag: "--status", list: true },
+  { 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" },
+  { flag: "--limit" },
+  { flag: "--offset" },
+  { flag: "--compact" },
+  { flag: "--brief" },
+  { flag: "--full" },
+  { flag: "--fields", list: true },
+  { flag: "--sort" },
+  { flag: "--order" },
+  { flag: "--include-body" },
+  { flag: "--stream" }
+];
+var AGGREGATE_FLAG_CONTRACTS = [
+  { flag: "--group-by", list: true },
+  { flag: "--count" },
+  { 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 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: "--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" },
+  { 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" },
+  { flag: "--validate-paths" },
+  { flag: "--audit" },
+  { flag: "--author" },
+  { flag: "--message" },
+  { flag: "--force" }
+];
+var HISTORY_FLAG_CONTRACTS = [
+  { flag: "--limit" },
+  { flag: "--compact" },
+  { flag: "--full" },
+  { flag: "--diff" },
+  { flag: "--verify" }
+];
+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: "--dry-run" },
+  { flag: "--author" },
+  { flag: "--message" },
+  { flag: "--force" }
+];
+var SCHEMA_FLAG_CONTRACTS = [
+  { flag: "--description" },
+  { flag: "--default-status", aliases: ["--default_status"] },
+  { flag: "--folder" },
+  { flag: "--alias" },
+  { 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", list: true },
+  { flag: "--priority" },
+  { flag: "--body" },
+  { flag: "--claim" },
+  { flag: "--from-search", aliases: ["--from_search"] },
+  { flag: "--step-title", aliases: ["--step", "--step_title"] },
+  { 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: "--defaults", short: "-y", aliases: ["--yes"] },
+  { flag: "--author" },
+  { flag: "--agent-guidance" },
+  { flag: "--with-packages" },
+  { 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: "--install" },
+  { flag: "--uninstall" },
+  { flag: "--explore" },
+  { flag: "--list" },
+  { flag: "--manage" },
+  { 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 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: "--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 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 TEST_FLAG_CONTRACTS = [
+  { flag: "--add" },
+  { flag: "--remove" },
+  { flag: "--run" },
+  { 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 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 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: "--check-files" },
+  { flag: "--scan-mode" },
+  { flag: "--include-pm-internals" },
+  { flag: "--verbose-file-lists" },
+  { flag: "--verbose-diagnostics" },
+  { flag: "--strict-exit" },
+  { flag: "--fail-on-warn" },
+  { flag: "--check-history-drift" },
+  { flag: "--check-command-references" }
+];
+var CREATE_FLAG_CONTRACTS = [
+  { short: "-t", flag: "--title" },
+  { 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", 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: "--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: "--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: "--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 UPDATE_FLAG_CONTRACTS = [
+  { short: "-t", flag: "--title" },
+  { short: "-d", flag: "--description" },
+  { short: "-b", flag: "--body" },
+  { short: "-s", flag: "--status" },
+  { flag: "--close-reason" },
+  { flag: "--close_reason" },
+  { short: "-p", flag: "--priority" },
+  { flag: "--type" },
+  { flag: "--tags", 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: "--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-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: "--rollback" },
+  { flag: "--no-checkpoint" },
+  { short: "-t", flag: "--title" },
+  { short: "-d", flag: "--description" },
+  { short: "-b", flag: "--body" },
+  { short: "-p", flag: "--priority" },
+  { flag: "--type" },
+  { flag: "--tags", 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: "--limit" },
+  { flag: "--format" },
+  { flag: "--depth" },
+  { flag: "--section" },
+  { flag: "--activity-limit" },
+  { flag: "--stale-threshold" }
+];
+var GET_FLAG_CONTRACTS = [
+  { flag: "--depth" },
+  { flag: "--full" },
+  { flag: "--fields", list: true }
+];
+var GUIDE_FLAG_CONTRACTS = [
+  { flag: "--list" },
+  { flag: "--format" },
+  { flag: "--depth" }
+];
+var DEPS_FLAG_CONTRACTS = [
+  { flag: "--format" },
+  { flag: "--max-depth" },
+  { flag: "--collapse" },
+  { flag: "--summary" }
+];
+var SEARCH_FLAG_CONTRACTS = [
+  { flag: "--mode" },
+  { flag: "--semantic" },
+  { flag: "--hybrid" },
+  { flag: "--include-linked" },
+  { flag: "--title-exact" },
+  { flag: "--phrase-exact" },
+  { flag: "--compact" },
+  { flag: "--full" },
+  { flag: "--fields", list: true },
+  { flag: "--limit" },
+  { flag: "--type" },
+  { flag: "--tag" },
+  { flag: "--priority" },
+  { flag: "--deadline-before" },
+  { flag: "--deadline-after" }
+];
+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_NAME_CONTRACTS = /* @__PURE__ */ new Set([
+  "list",
+  "list-all",
+  "list-draft",
+  "list-open",
+  "list-in-progress",
+  "list-blocked",
+  "list-closed",
+  "list-canceled"
+]);
+var NO_SURFACE_COMMAND_NAME_CONTRACTS = /* @__PURE__ */ new Set([
+  "stats",
+  "reindex",
+  "help"
+]);
+function normalizeCommandNameForContracts(commandName) {
+  if (typeof commandName !== "string") {
+    return "";
+  }
+  return commandName.trim().toLowerCase();
+}
+function resolveSubcommandFlagContractsForCommand(commandName) {
+  const normalized = normalizeCommandNameForContracts(commandName);
+  if (normalized.length === 0) {
+    return withSubcommandGlobalFlags([]);
+  }
+  if (LIST_COMMAND_NAME_CONTRACTS.has(normalized)) {
+    return withSubcommandGlobalFlags(LIST_FILTER_FLAG_CONTRACTS);
+  }
+  if (NO_SURFACE_COMMAND_NAME_CONTRACTS.has(normalized)) {
+    return withSubcommandGlobalFlags([]);
+  }
+  if (normalized === "templates") {
+    return withSubcommandGlobalFlags(CREATE_FLAG_CONTRACTS);
+  }
+  if (normalized === "cal") {
+    return withSubcommandGlobalFlags(CALENDAR_FLAG_CONTRACTS);
+  }
+  if (normalized === "ctx") {
+    return withSubcommandGlobalFlags(CONTEXT_FLAG_CONTRACTS);
+  }
+  if (normalized === "test-runs-worker") {
+    return withSubcommandGlobalFlags(TEST_RUNS_FLAG_CONTRACTS);
+  }
+  switch (normalized) {
+    case "init":
+      return withSubcommandGlobalFlags(INIT_FLAG_CONTRACTS);
+    case "config":
+      return withSubcommandGlobalFlags(CONFIG_FLAG_CONTRACTS);
+    case "extension":
+    case "package":
+    case "packages":
+      return withSubcommandGlobalFlags(EXTENSION_FLAG_CONTRACTS);
+    case "install":
+      return withSubcommandGlobalFlags(INSTALL_FLAG_CONTRACTS);
+    case "upgrade":
+      return withSubcommandGlobalFlags(UPGRADE_FLAG_CONTRACTS);
+    case "create":
+      return withSubcommandGlobalFlags(CREATE_FLAG_CONTRACTS);
+    case "aggregate":
+      return withSubcommandGlobalFlags(AGGREGATE_FLAG_CONTRACTS);
+    case "calendar":
+      return withSubcommandGlobalFlags(CALENDAR_FLAG_CONTRACTS);
+    case "context":
+      return withSubcommandGlobalFlags(CONTEXT_FLAG_CONTRACTS);
+    case "get":
+      return withSubcommandGlobalFlags(GET_FLAG_CONTRACTS);
+    case "search":
+      return withSubcommandGlobalFlags(SEARCH_FLAG_CONTRACTS);
+    case "history":
+      return withSubcommandGlobalFlags(HISTORY_FLAG_CONTRACTS);
+    case "history-redact":
+      return withSubcommandGlobalFlags(HISTORY_REDACT_FLAG_CONTRACTS);
+    case "history-repair":
+      return withSubcommandGlobalFlags(HISTORY_REPAIR_FLAG_CONTRACTS);
+    case "schema":
+      return withSubcommandGlobalFlags(SCHEMA_FLAG_CONTRACTS);
+    case "plan":
+      return withSubcommandGlobalFlags(PLAN_FLAG_CONTRACTS);
+    case "activity":
+      return withSubcommandGlobalFlags(ACTIVITY_FLAG_CONTRACTS);
+    case "restore":
+      return withSubcommandGlobalFlags(RESTORE_FLAG_CONTRACTS);
+    case "update":
+      return withSubcommandGlobalFlags(UPDATE_FLAG_CONTRACTS);
+    case "update-many":
+      return withSubcommandGlobalFlags(UPDATE_MANY_FLAG_CONTRACTS);
+    case "close":
+      return withSubcommandGlobalFlags(CLOSE_FLAG_CONTRACTS);
+    case "delete":
+      return withSubcommandGlobalFlags(DELETE_FLAG_CONTRACTS);
+    case "append":
+      return withSubcommandGlobalFlags(APPEND_FLAG_CONTRACTS);
+    case "comments":
+      return withSubcommandGlobalFlags(COMMENTS_FLAG_CONTRACTS);
+    case "notes":
+      return withSubcommandGlobalFlags(NOTES_FLAG_CONTRACTS);
+    case "learnings":
+      return withSubcommandGlobalFlags(LEARNINGS_FLAG_CONTRACTS);
+    case "files":
+      return withSubcommandGlobalFlags(FILES_FLAG_CONTRACTS);
+    case "docs":
+      return withSubcommandGlobalFlags(DOCS_FLAG_CONTRACTS);
+    case "deps":
+      return withSubcommandGlobalFlags(DEPS_FLAG_CONTRACTS);
+    case "test":
+      return withSubcommandGlobalFlags(TEST_FLAG_CONTRACTS);
+    case "test-all":
+      return withSubcommandGlobalFlags(TEST_ALL_FLAG_CONTRACTS);
+    case "health":
+      return withSubcommandGlobalFlags(HEALTH_FLAG_CONTRACTS);
+    case "validate":
+      return withSubcommandGlobalFlags(VALIDATE_FLAG_CONTRACTS);
+    case "gc":
+      return withSubcommandGlobalFlags(GC_FLAG_CONTRACTS);
+    case "contracts":
+      return withSubcommandGlobalFlags(CONTRACTS_FLAG_CONTRACTS);
+    case "claim":
+      return withSubcommandGlobalFlags(CLAIM_FLAG_CONTRACTS);
+    case "release":
+      return withSubcommandGlobalFlags(RELEASE_FLAG_CONTRACTS);
+    case "start-task":
+      return withSubcommandGlobalFlags(START_TASK_FLAG_CONTRACTS);
+    case "pause-task":
+      return withSubcommandGlobalFlags(PAUSE_TASK_FLAG_CONTRACTS);
+    case "close-task":
+      return withSubcommandGlobalFlags(CLOSE_TASK_FLAG_CONTRACTS);
+    default:
+      return withSubcommandGlobalFlags([]);
+  }
+}
+var PM_TOOL_GLOBAL_PARAMETER_KEYS = ["json", "quiet", "profile", "noExtensions", "noPager", "path", "pmExecutable", "timeoutMs"];
+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 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",
+  "compact",
+  "brief",
+  "full"
+]);
+var AGGREGATE_CONTRACT_PARAMETER_KEYS = toSchemaKeyList([
+  ...TOOL_AGGREGATE_OPTION_CONTRACTS.map((entry) => entry.param),
+  "count",
+  "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",
+  "compact",
+  "full",
+  ...TOOL_SEARCH_FILTER_OPTION_CONTRACTS.map((entry) => entry.param)
+]);
+var AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS = ["author", "message", "force"];
+var PM_TOOL_ACTION_SCHEMA_CONTRACTS = {
+  init: { optional: ["prefix", "preset", "defaults", "author", "agentGuidance", "withPackages"] },
+  config: {
+    required: ["scope", "configAction"],
+    optional: ["key", "value", "criterion", "clearCriteria", "format", "policy"]
+  },
+  "extension-init": { required: ["target"], optional: ["scope"] },
+  "extension-install": {
+    optional: ["target", "github", "scope", "ref"],
+    anyOfRequired: [["target"], ["github"]]
+  },
+  "extension-uninstall": { required: ["target"], optional: ["scope"] },
+  "extension-explore": { optional: ["scope"] },
+  "extension-manage": { optional: ["scope", "runtimeProbe", "fixManagedState"] },
+  "extension-reload": { optional: ["scope", "watch"] },
+  "extension-doctor": { optional: ["scope", "detail", "trace", "fixManagedState", "strictExit", "failOnWarn"] },
+  "extension-catalog": { optional: ["scope"] },
+  "extension-adopt": { required: ["target"], optional: ["scope", "github", "ref"] },
+  "extension-adopt-all": { optional: ["scope"] },
+  "extension-activate": { required: ["target"], optional: ["scope"] },
+  "extension-deactivate": { required: ["target"], optional: ["scope"] },
+  extension: {
+    optional: [
+      "target",
+      "scope",
+      "github",
+      "ref",
+      "init",
+      "install",
+      "uninstall",
+      "explore",
+      "manage",
+      "reload",
+      "doctor",
+      "catalog",
+      "adopt",
+      "adoptAll",
+      "activate",
+      "deactivate",
+      "runtimeProbe",
+      "fixManagedState",
+      "detail",
+      "trace",
+      "watch",
+      "strictExit",
+      "failOnWarn"
+    ]
+  },
+  "package-init": { required: ["target"], optional: ["scope"] },
+  "package-install": {
+    optional: ["target", "github", "scope", "ref"],
+    anyOfRequired: [["target"], ["github"]]
+  },
+  "package-uninstall": { required: ["target"], optional: ["scope"] },
+  "package-explore": { optional: ["scope"] },
+  "package-manage": { optional: ["scope", "runtimeProbe", "fixManagedState"] },
+  "package-reload": { optional: ["scope", "watch"] },
+  "package-doctor": { optional: ["scope", "detail", "trace", "fixManagedState", "strictExit", "failOnWarn"] },
+  "package-catalog": { optional: ["scope"] },
+  "package-adopt": { required: ["target"], optional: ["scope", "github", "ref"] },
+  "package-adopt-all": { optional: ["scope"] },
+  "package-activate": { required: ["target"], optional: ["scope"] },
+  "package-deactivate": { required: ["target"], optional: ["scope"] },
+  package: {
+    optional: [
+      "target",
+      "scope",
+      "github",
+      "ref",
+      "init",
+      "install",
+      "uninstall",
+      "explore",
+      "manage",
+      "reload",
+      "doctor",
+      "catalog",
+      "adopt",
+      "adoptAll",
+      "activate",
+      "deactivate",
+      "runtimeProbe",
+      "fixManagedState",
+      "detail",
+      "trace",
+      "watch",
+      "strictExit",
+      "failOnWarn"
+    ]
+  },
+  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
+  },
+  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: ["format", "depth"] },
+  context: { optional: CONTEXT_CONTRACT_PARAMETER_KEYS },
+  ctx: { optional: CONTEXT_CONTRACT_PARAMETER_KEYS },
+  get: { required: ["id"], optional: ["depth", "full", "fields"] },
+  search: {
+    optional: SEARCH_CONTRACT_PARAMETER_KEYS,
+    anyOfRequired: [["query"], ["keywords"]]
+  },
+  reindex: { optional: ["mode", "progress"] },
+  history: { required: ["id"], optional: ["limit", "compact", "full", "diff", "verify"] },
+  "history-redact": {
+    required: ["id"],
+    optional: ["literal", "regex", "replacement", "dryRun", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS],
+    anyOfRequired: [["literal"], ["regex"]]
+  },
+  "history-repair": {
+    required: ["id"],
+    optional: ["dryRun", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS]
+  },
+  schema: {
+    required: ["subcommand", "name"],
+    // No --message: schema add-type writes a config file, not item history.
+    optional: ["description", "defaultStatus", "folder", "alias", "author", "force"]
+  },
+  plan: {
+    required: ["subcommand"],
+    optional: [
+      "id",
+      "stepRef",
+      "reorderTo",
+      "title",
+      "description",
+      "scope",
+      "parent",
+      "related",
+      "blocks",
+      "blockedBy",
+      "harness",
+      "mode",
+      "resumeContext",
+      "tags",
+      "priority",
+      "body",
+      "claim",
+      "fromSearch",
+      "stepTitle",
+      "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", "text"], optional: ["validateClose", ...AUTHOR_MESSAGE_FORCE_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", "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",
+      "discover",
+      "apply",
+      "discoveryNote",
+      "appendStable",
+      "validatePaths",
+      "audit",
+      ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS
+    ]
+  },
+  docs: {
+    required: ["id"],
+    optional: ["add", "addGlob", "remove", "migrate", "validatePaths", "audit", ...AUTHOR_MESSAGE_FORCE_PARAMETER_KEYS]
+  },
+  deps: { required: ["id"], optional: ["format", "maxDepth", "collapse", "summary"] },
+  test: {
+    required: ["id"],
+    optional: [
+      "add",
+      "remove",
+      "run",
+      "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"
+    ]
+  },
+  "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: {},
+  health: {
+    optional: [
+      "strictDirectories",
+      "strictExit",
+      "failOnWarn",
+      "checkOnly",
+      "checkTelemetry",
+      "noRefresh",
+      "refreshVectors",
+      "verboseStaleItems",
+      "summary",
+      "skipVectors",
+      "skipIntegrity",
+      "skipDrift",
+      "full"
+    ]
+  },
+  validate: {
+    optional: [
+      "checkMetadata",
+      "metadataProfile",
+      "checkResolution",
+      "checkLifecycle",
+      "checkStaleBlockers",
+      "dependencyCycleSeverity",
+      "checkFiles",
+      "scanMode",
+      "includePmInternals",
+      "verboseFileLists",
+      "verboseDiagnostics",
+      "strictExit",
+      "failOnWarn",
+      "checkHistoryDrift",
+      "checkCommandReferences"
+    ]
+  },
+  gc: { optional: ["dryRun", "gcScope"] },
+  contracts: { optional: ["contractAction", "command", "schemaOnly", "flagsOnly", "availabilityOnly", "runtimeOnly", "activeOnly"] },
+  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", "text"], optional: 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];
+  }
+  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];
+  }
+  return PM_TOOL_PARAMETER_PROPERTIES[key];
+}
+function buildActionScopedToolSchema(action) {
+  const contract = PM_TOOL_ACTION_SCHEMA_CONTRACTS[action];
+  const required = toSchemaKeyList(contract.required ?? []);
+  const optional = toSchemaKeyList(contract.optional ?? []);
+  const allowedKeys = toSchemaKeyList([...PM_TOOL_GLOBAL_PARAMETER_KEYS, ...required, ...optional]);
+  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);
+    }
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: false,
+    required: ["action", ...required],
+    title: `pm action "${action}" parameters`,
+    properties
+  };
+  if (contract.anyOfRequired && contract.anyOfRequired.length > 0) {
+    schema.anyOf = contract.anyOfRequired.map((requiredFields) => ({
+      required: [...requiredFields]
+    }));
+  }
+  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 = createLazyContractSchema(() => ({
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schema.unbrained.dev/pm-cli/tool-parameters-v4.schema.json",
+  title: "pm-cli tool parameters (action-scoped strict schema)",
+  "x-schema-version": "4.0.1",
+  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 {
+      ...rest2,
+      type: firstTypedVariant.type
+    };
+  }
+  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": "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["action"],
+    properties
+  };
+}
+var PM_PROVIDER_TOOL_PARAMETERS_SCHEMA = createLazyContractSchema(buildProviderCompatibleToolSchema);
+
+export {
+  LIST_COMMANDER_STRING_OPTION_CONTRACTS,
+  SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
+  CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS,
+  CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
+  ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
+  readFirstStringFromCommanderOptions,
+  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,
+  compactFlagAliasContracts,
+  GLOBAL_FLAG_CONTRACTS,
+  LIST_FILTER_FLAG_CONTRACTS,
+  AGGREGATE_FLAG_CONTRACTS,
+  DEDUPE_AUDIT_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,
+  SCHEMA_FLAG_CONTRACTS,
+  PLAN_FLAG_CONTRACTS,
+  INIT_FLAG_CONTRACTS,
+  CONFIG_FLAG_CONTRACTS,
+  EXTENSION_FLAG_CONTRACTS,
+  INSTALL_FLAG_CONTRACTS,
+  UPGRADE_FLAG_CONTRACTS,
+  REINDEX_FLAG_CONTRACTS,
+  CLOSE_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,
+  TEST_FLAG_CONTRACTS,
+  TEST_ALL_FLAG_CONTRACTS,
+  TEST_RUNS_FLAG_CONTRACTS,
+  GC_FLAG_CONTRACTS,
+  HEALTH_FLAG_CONTRACTS,
+  VALIDATE_FLAG_CONTRACTS,
+  CREATE_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,
+  SEARCH_FLAG_CONTRACTS,
+  CONTRACTS_FLAG_CONTRACTS,
+  COMPLETION_FLAG_CONTRACTS,
+  resolveSubcommandFlagContractsForCommand,
+  PM_TOOL_PARAMETERS_SCHEMA
+};
+//# sourceMappingURL=chunk-GN7IJPCD.js.map