@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-5GZ7TDD6.js

@@ -0,0 +1,1868 @@
+import {
+  ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
+  ACTIVITY_FLAG_CONTRACTS,
+  AGGREGATE_FLAG_CONTRACTS,
+  APPEND_FLAG_CONTRACTS,
+  CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS,
+  CALENDAR_FLAG_CONTRACTS,
+  CLAIM_FLAG_CONTRACTS,
+  CLOSE_FLAG_CONTRACTS,
+  CLOSE_MANY_FLAG_CONTRACTS,
+  CLOSE_TASK_FLAG_CONTRACTS,
+  COMMENTS_AUDIT_FLAG_CONTRACTS,
+  COMMENTS_FLAG_CONTRACTS,
+  COMPLETION_FLAG_CONTRACTS,
+  CONFIG_FLAG_CONTRACTS,
+  CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
+  CONTEXT_FLAG_CONTRACTS,
+  CONTRACTS_FLAG_CONTRACTS,
+  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+  CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
+  CREATE_FLAG_CONTRACTS,
+  DEDUPE_AUDIT_FLAG_CONTRACTS,
+  DEDUPE_MERGE_FLAG_CONTRACTS,
+  DELETE_FLAG_CONTRACTS,
+  DEPS_FLAG_CONTRACTS,
+  DOCS_FLAG_CONTRACTS,
+  EVAL_FLAG_CONTRACTS,
+  EXTENSION_ACTIVATE_FLAG_CONTRACTS,
+  EXTENSION_ADOPT_ALL_FLAG_CONTRACTS,
+  EXTENSION_ADOPT_FLAG_CONTRACTS,
+  EXTENSION_CATALOG_FLAG_CONTRACTS,
+  EXTENSION_DEACTIVATE_FLAG_CONTRACTS,
+  EXTENSION_DESCRIBE_FLAG_CONTRACTS,
+  EXTENSION_DOCTOR_FLAG_CONTRACTS,
+  EXTENSION_EXPLORE_FLAG_CONTRACTS,
+  EXTENSION_FLAG_CONTRACTS,
+  EXTENSION_INIT_FLAG_CONTRACTS,
+  EXTENSION_INSTALL_FLAG_CONTRACTS,
+  EXTENSION_MANAGE_FLAG_CONTRACTS,
+  EXTENSION_RELOAD_FLAG_CONTRACTS,
+  EXTENSION_UNINSTALL_FLAG_CONTRACTS,
+  FILES_FLAG_CONTRACTS,
+  GC_FLAG_CONTRACTS,
+  GET_FLAG_CONTRACTS,
+  GLOBAL_FLAG_CONTRACTS,
+  GUIDE_FLAG_CONTRACTS,
+  HEALTH_FLAG_CONTRACTS,
+  HISTORY_COMPACT_FLAG_CONTRACTS,
+  HISTORY_FLAG_CONTRACTS,
+  HISTORY_REDACT_FLAG_CONTRACTS,
+  HISTORY_REPAIR_FLAG_CONTRACTS,
+  INIT_FLAG_CONTRACTS,
+  INSTALL_FLAG_CONTRACTS,
+  LEARNINGS_FLAG_CONTRACTS,
+  LIST_COMMANDER_STRING_OPTION_CONTRACTS,
+  LIST_FILTER_FLAG_CONTRACTS,
+  NEXT_FLAG_CONTRACTS,
+  NORMALIZE_FLAG_CONTRACTS,
+  NOTES_FLAG_CONTRACTS,
+  PACKAGE_FLAG_CONTRACTS,
+  PACKAGE_INIT_FLAG_CONTRACTS,
+  PAUSE_TASK_FLAG_CONTRACTS,
+  PLAN_FLAG_CONTRACTS,
+  PM_CORE_COMMAND_NAMES,
+  PM_EXTENSION_CAPABILITY_CONTRACTS,
+  PM_EXTENSION_POLICY_MODE_CONTRACTS,
+  PM_EXTENSION_POLICY_SURFACE_CONTRACTS,
+  PM_EXTENSION_SANDBOX_PROFILE_CONTRACTS,
+  PM_EXTENSION_SERVICE_NAME_CONTRACTS,
+  PM_EXTENSION_TRUST_MODE_CONTRACTS,
+  PM_TOOL_ACTIONS,
+  PM_TOOL_PARAMETERS_SCHEMA,
+  PROFILE_FLAG_CONTRACTS,
+  REINDEX_FLAG_CONTRACTS,
+  RELEASE_FLAG_CONTRACTS,
+  RESTORE_FLAG_CONTRACTS,
+  SCHEMA_FLAG_CONTRACTS,
+  SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
+  SEARCH_FLAG_CONTRACTS,
+  START_TASK_FLAG_CONTRACTS,
+  STATS_FLAG_CONTRACTS,
+  TELEMETRY_FLAG_CONTRACTS,
+  TEST_ALL_FLAG_CONTRACTS,
+  TEST_FLAG_CONTRACTS,
+  TEST_RUNS_FLAG_CONTRACTS,
+  UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+  UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
+  UPDATE_FLAG_CONTRACTS,
+  UPDATE_MANY_FLAG_CONTRACTS,
+  UPGRADE_FLAG_CONTRACTS,
+  VALIDATE_FLAG_CONTRACTS,
+  compactFlagAliasContracts
+} from "./chunk-VIIUS6N6.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  RUNTIME_STATUS_ROLE_VALUES,
+  SETTINGS_DEFAULTS,
+  activateExtensions,
+  commandOptionFlagLabel,
+  getSettingsPath,
+  loadExtensions,
+  pathExists,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry
+} from "./chunk-LK6XLOGP.js";
+
+// dist/mcp/tool-definitions.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] = "2985c46c-49c8-53d2-b31c-5e1531b7b3ff");
+  } catch (e2) {
+  }
+})();
+var TOOL_SCHEMA_BASE = {
+  type: "object",
+  properties: {
+    cwd: {
+      type: "string",
+      description: "Workspace directory to run the native pm operation in. Defaults to the MCP server process cwd."
+    },
+    path: {
+      type: "string",
+      description: "Optional pm data root, equivalent to PM_PATH/global --path. Leave unset for real repository tracking."
+    },
+    author: {
+      type: "string",
+      description: "Mutation author. Defaults to PM_AUTHOR or pm settings when supported by the underlying operation."
+    }
+  },
+  additionalProperties: true
+};
+var idSchema = {
+  type: "string",
+  description: "pm item id, for example pm-abc1."
+};
+var PM_RUN_ACTION_DESCRIPTION = `Operation name (one of): ${PM_TOOL_ACTIONS.join(", ")}. Package-owned actions (for example calendar/templates/guide/dedupe-audit/normalize/reindex/comments-audit/completion/test-runs-list/test-runs-status/test-runs-logs/test-runs-stop/test-runs-resume) are available dynamically when installed.`;
+var LIST_TOP_LEVEL_OPTION_PROPERTIES = {
+  status: { type: "string", description: "Alias for options.status." },
+  type: { type: "string", description: "Alias for options.type." },
+  tag: { type: "string", description: "Alias for options.tag." },
+  priority: { type: "string", description: "Alias for options.priority." },
+  limit: { type: ["string", "number"], description: "Alias for options.limit." },
+  offset: { type: ["string", "number"], description: "Alias for options.offset." }
+};
+var SEARCH_TOP_LEVEL_OPTION_PROPERTIES = {
+  mode: { type: "string", description: "Alias for options.mode." },
+  status: { type: "string", description: "Alias for options.status." },
+  type: { type: "string", description: "Alias for options.type." },
+  tag: { type: "string", description: "Alias for options.tag." },
+  priority: { type: "string", description: "Alias for options.priority." },
+  limit: { type: ["string", "number"], description: "Alias for options.limit." }
+};
+function objectSchema(properties, required = []) {
+  return {
+    ...TOOL_SCHEMA_BASE,
+    properties: {
+      ...TOOL_SCHEMA_BASE.properties,
+      ...properties
+    },
+    required
+  };
+}
+var TOOLS = [
+  {
+    name: "pm_run",
+    description: "Run any supported pm operation natively through the pm library. Use this for commands not covered by narrower pm_* tools.",
+    inputSchema: objectSchema({
+      action: {
+        type: "string",
+        description: PM_RUN_ACTION_DESCRIPTION
+      },
+      id: idSchema,
+      query: { type: "string", description: "Search query for action=search." },
+      reason: { type: "string", description: "Close reason for action=close." },
+      force: { type: "boolean", description: "Force ownership/terminal-state override when supported." },
+      // pm-v68d: the schema-specific subcommand enum and add-type/add-status
+      // properties migrated to the dedicated pm_schema tool. action=schema
+      // still accepts them as passthrough, but agents should prefer pm_schema.
+      subcommand: {
+        type: "string",
+        description: "Subcommand selector for actions that take one (for example telemetry, or schema \u2014 prefer the dedicated pm_schema tool for schema operations)."
+      },
+      options: { type: "object", description: "Underlying pm command options using camelCase keys." },
+      fullChangedFields: {
+        type: "boolean",
+        description: "For mutation actions, return the full changed_fields array instead of the default changed_field_count."
+      },
+      idOnly: {
+        type: "boolean",
+        description: "For single-item mutation actions, return only id and status."
+      }
+    }, ["action"])
+  },
+  {
+    name: "pm_context",
+    description: "Return the agent-oriented project context snapshot. Pass options.depth=brief|standard|deep|full (full = every section with no per-section row cap), options.parent='<id>' to scope the snapshot to one item's subtree (the item plus all descendants), options.fields='id,title,priority' to project focus rows to a field subset for low-token reads, or options.section=['hierarchy','progress',...] to pick sections.",
+    inputSchema: objectSchema({ options: { type: "object" } })
+  },
+  {
+    name: "pm_next",
+    description: "Recommend the next actionable work item: the single highest-priority READY item (active status, no open blockers, no open children; completed containers surface only when no concrete leaf work is ready) plus the ranked ready and blocked queues. The recommended item carries a rationale and each blocked item lists the open blockers gating it. Pass options.parent='<id>' to scope to one subtree, options.limit=N to cap ready rows, options.readyOnly=true to omit the blocked list, or filters (options.type/tag/priority/assignee/sprint/release). The most token-efficient 'what should I do now?' read for agents.",
+    inputSchema: objectSchema({ options: { type: "object" } })
+  },
+  {
+    name: "pm_search",
+    description: "Search pm items with keyword, semantic, or hybrid search. Defaults to a compact projection for token efficiency. Pass options.mode=keyword|semantic|hybrid, options.limit=N to cap hits, options.status='all' for no lifecycle restriction, options.fields='id,title,score' for a custom projection, or options.full=true for full item bodies (can be large). The result echoes the applied filters and projection mode in query_summary.",
+    inputSchema: objectSchema({ query: { type: "string" }, options: { type: "object" }, ...SEARCH_TOP_LEVEL_OPTION_PROPERTIES }, ["query"])
+  },
+  {
+    name: "pm_list",
+    description: "List pm items with status/type/tag/priority filters. Defaults to compact projection for token efficiency. options.status accepts CSV (all,open,in_progress). Pass options.compact=false or options.includeBody=true for full bodies/comments. Pass options.brief=true for ultra-terse (id/status/type/title only). Pass options.fields='id,title,priority' for custom projection. Pass options.limit=N to cap row count. The result echoes the applied filters and projection mode in query_summary.",
+    inputSchema: objectSchema({ options: { type: "object" }, ...LIST_TOP_LEVEL_OPTION_PROPERTIES })
+  },
+  {
+    name: "pm_get",
+    description: "Read one pm item. Pass options.depth='brief' or options.fields='id,title,status' for low-token inspection.",
+    inputSchema: objectSchema({
+      id: idSchema,
+      options: { type: "object", description: "Get options such as depth=brief|standard|deep|full or fields=id,title,status." }
+    }, ["id"])
+  },
+  {
+    name: "pm_create",
+    description: "Create a pm item natively and write pm history. Output is compact by default (changed_fields replaced with changed_field_count for token efficiency); pass fullChangedFields=true for the full changed_fields array.",
+    inputSchema: objectSchema({
+      fullChangedFields: { type: "boolean", description: "Return full changed_fields instead of changed_field_count." },
+      allowMissingParent: { type: "boolean", description: "Allow unresolved parent references and emit a validation warning." },
+      options: { type: "object", description: "Create options. title and description are required." }
+    }, ["options"])
+  },
+  {
+    name: "pm_copy",
+    description: "Copy an existing pm item into a new id while resetting lifecycle fields. Output is compact by default (changed_fields replaced with changed_field_count); pass fullChangedFields=true for the full changed_fields array.",
+    inputSchema: objectSchema({
+      id: idSchema,
+      fullChangedFields: { type: "boolean", description: "Return full changed_fields instead of changed_field_count." },
+      options: { type: "object", description: "Copy options such as title override, author, and message." }
+    }, ["id"])
+  },
+  {
+    name: "pm_focus",
+    description: "Set, clear, or show the session focused item. When focused, pm_create defaults its parent to the focused item (an explicit parent still overrides). Pass id to focus an item, options.clear=true to clear, or neither to show current focus.",
+    inputSchema: objectSchema({
+      id: idSchema,
+      clear: { type: "boolean", description: "Clear the focused item (cannot be combined with id)." },
+      options: { type: "object", description: "Focus options such as clear (boolean)." }
+    }, [])
+  },
+  {
+    name: "pm_update",
+    description: "Update pm item metadata/body/dependencies/log seeds natively. Output is compact by default (changed_fields replaced with changed_field_count); pass fullChangedFields=true for the full changed_fields delta.",
+    inputSchema: objectSchema({
+      id: idSchema,
+      fullChangedFields: { type: "boolean", description: "Return full changed_fields instead of changed_field_count." },
+      options: { type: "object" }
+    }, ["id", "options"])
+  },
+  {
+    name: "pm_append",
+    description: "Append markdown text to a pm item body and write pm history. Useful for seeding evidence/log entries before close. Output is compact by default (changed_fields replaced with changed_field_count); pass fullChangedFields=true for the full changed_fields array.",
+    inputSchema: objectSchema({
+      id: idSchema,
+      body: {
+        type: "string",
+        description: "Markdown text to append to the item body. Required here or as options.body."
+      },
+      fullChangedFields: { type: "boolean", description: "Return full changed_fields instead of changed_field_count." },
+      options: { type: "object", description: "Append options such as body, author, and message." }
+    }, ["id"])
+  },
+  {
+    name: "pm_claim",
+    description: "Claim a pm item.",
+    inputSchema: objectSchema({ id: idSchema, force: { type: "boolean" }, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_release",
+    description: "Release a pm item claim.",
+    inputSchema: objectSchema({ id: idSchema, force: { type: "boolean" }, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_close",
+    description: "Close a pm item with optional close reason and optional close validation (reason requirement follows governance settings). Output is compact by default (changed_fields replaced with changed_field_count); pass fullChangedFields=true for the full changed_fields array.",
+    inputSchema: objectSchema({
+      id: idSchema,
+      reason: { type: "string", description: "Close reason text when provided or required by governance settings." },
+      duplicateOf: { type: "string", description: "Canonical item id when closing this item as a duplicate." },
+      fullChangedFields: { type: "boolean", description: "Return full changed_fields instead of changed_field_count." },
+      idOnly: { type: "boolean", description: "Return only id and status." },
+      options: { type: "object" }
+    }, ["id"])
+  },
+  {
+    name: "pm_comments",
+    description: "List, add, edit, or delete comments on a pm item. Use options.add to append, options.edit=<1-based index> with replacement text to fix a comment, or options.delete=<1-based index> to remove one. List calls default to the most recent 20 comments with total_count/has_more metadata for token efficiency. Pass options.limit=N to choose a page size, options.limit=0 for summary-only metadata, or options.full=true for full history.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_files",
+    description: "List, add, remove, audit, or validate linked files for a pm item.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_docs",
+    description: "List, add, or remove linked docs for a pm item.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_notes",
+    description: "List or add structured notes on a pm item. Use options.add to append a note; omit it to list existing notes.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_learnings",
+    description: "List or add learnings on a pm item. Use options.add to capture a learning/insight; omit it to list existing learnings.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_deps",
+    description: "List, add, or remove dependencies for a pm item. Use options.add to declare a dependency and options.remove to drop one; omit both to list current dependencies.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_test",
+    description: "List, add, remove, or run linked tests for a pm item.",
+    inputSchema: objectSchema({ id: idSchema, options: { type: "object" } }, ["id"])
+  },
+  {
+    name: "pm_validate",
+    description: "Run pm validation checks.",
+    inputSchema: objectSchema({ options: { type: "object" } })
+  },
+  {
+    name: "pm_health",
+    description: "Run pm health diagnostics. Pass options.brief=true for compact low-token details, options.skipIntegrity=true, options.skipDrift=true, options.skipVectors=true for a fast status-only check, or options.full=true for the complete deep check.",
+    inputSchema: objectSchema({ options: { type: "object" } })
+  },
+  {
+    name: "pm_contracts",
+    description: "Inspect pm command, flag, schema, and availability contracts.",
+    inputSchema: objectSchema({ options: { type: "object" } })
+  },
+  {
+    name: "pm_schema",
+    description: "Inspect or modify the workspace item-type/status/field schema (pm schema). subcommand selects the operation; name carries the item type name (show/add-type/remove-type), status id (show-status/add-status/remove-status), or field key (show-field/add-field/remove-field). apply-preset adopts a domain type preset; add-type with infer=true derives types from title-prefix conventions. Schema mutations write workspace config files, not item history.",
+    inputSchema: objectSchema({
+      subcommand: {
+        type: "string",
+        enum: [
+          "list",
+          "show",
+          "show-status",
+          "add-type",
+          "remove-type",
+          "add-status",
+          "remove-status",
+          "add-field",
+          "remove-field",
+          "list-fields",
+          "show-field",
+          "apply-preset"
+        ],
+        description: "Schema subcommand to run."
+      },
+      name: {
+        type: "string",
+        description: "Item type name (show/add-type/remove-type), status id (show-status/add-status/remove-status), or custom field key (show-field/add-field/remove-field). Required for those subcommands."
+      },
+      description: {
+        type: "string",
+        description: "Custom item type, status, or field description for add-type/add-status/add-field."
+      },
+      defaultStatus: { type: "string", description: "Default status for add-type." },
+      folder: { type: "string", description: "Storage folder for add-type." },
+      alias: {
+        type: "array",
+        items: { type: "string" },
+        description: "Aliases for add-type/add-status, or extra CLI flag aliases for add-field."
+      },
+      role: {
+        type: "array",
+        items: { type: "string", enum: [...RUNTIME_STATUS_ROLE_VALUES] },
+        description: `Lifecycle roles for add-status: ${RUNTIME_STATUS_ROLE_VALUES.join(", ")}.`
+      },
+      order: { type: "number", description: "Display/sort order for add-status." },
+      fieldType: {
+        type: "string",
+        enum: ["string", "number", "boolean", "string_array"],
+        description: "Value type for a custom field (add-field)."
+      },
+      commands: {
+        type: "array",
+        items: { type: "string" },
+        description: "Commands a custom field is wired onto (add-field): create, update, update_many, list, search, calendar, context."
+      },
+      cliFlag: { type: "string", description: "Override the auto-derived CLI flag for a custom field (add-field)." },
+      required: { type: "boolean", description: "Mark a custom field as always required (add-field)." },
+      requiredOnCreate: { type: "boolean", description: "Mark a custom field as required at create time (add-field)." },
+      allowUnset: { type: "boolean", description: "Whether a custom field may be cleared via --unset (add-field); defaults to true." },
+      requiredTypes: {
+        type: "array",
+        items: { type: "string" },
+        description: "Restrict a custom field's requirement to specific item types (add-field)."
+      },
+      typePreset: {
+        type: "string",
+        enum: ["agile", "ops", "research"],
+        description: "Domain type preset to adopt (apply-preset)."
+      },
+      infer: { type: "boolean", description: "Infer item types from title-prefix conventions (add-type); previews unless apply is true." },
+      minCount: { type: "number", description: "Minimum items sharing a prefix for add-type inference (default 10)." },
+      apply: { type: "boolean", description: "Register inferred types (add-type infer); without it the call previews only." },
+      force: { type: "boolean", description: "Override removal guardrails for destructive schema changes when supported." },
+      options: { type: "object", description: "Additional schema options using camelCase keys." }
+    }, ["subcommand"])
+  },
+  {
+    name: "pm_profile",
+    description: "List, show, apply, or lint project profiles (pm profile) \u2014 archetype bundles that stage item types, statuses, fields, per-type workflows, config knobs, create templates, and recommended packages. subcommand selects the operation; name carries the profile name (agile, ops, research) for show/apply/lint. apply stages every dimension idempotently; dryRun previews the diff without writing; lint reports author-time consistency findings (graded error/warning) without touching the tracker. Profile staging writes workspace config/schema files, not item history.",
+    inputSchema: objectSchema({
+      subcommand: {
+        type: "string",
+        enum: ["list", "show", "apply", "lint"],
+        description: "Profile subcommand to run."
+      },
+      name: {
+        type: "string",
+        description: "Profile name for show/apply/lint. Required for those subcommands. Built-ins are agile, ops, and research; an active extension can contribute additional archetype names that resolve here too."
+      },
+      dryRun: { type: "boolean", description: "Preview the apply diff without writing any files (apply)." },
+      author: { type: "string", description: "Mutation author for apply." },
+      force: { type: "boolean", description: "Force ownership/lock override for apply." },
+      options: { type: "object", description: "Additional profile options using camelCase keys." }
+    }, ["subcommand"])
+  },
+  {
+    name: "pm_config",
+    description: "Read or write pm workspace configuration (pm config). configAction selects get/set/list/export; key/value address a single setting for get/set. scope chooses the project (default) or global settings file.",
+    inputSchema: objectSchema({
+      configAction: {
+        type: "string",
+        enum: ["get", "set", "list", "export"],
+        description: "Config operation to perform. get/set require key; list/export dump the resolved settings surface."
+      },
+      key: {
+        type: "string",
+        description: "Settings key for get/set, for example governance-require-close-reason, telemetry-tracking, or a nested leaf such as search_provider (dash and underscore variants accepted; configAction=get without a key lists supported keys in the error)."
+      },
+      value: { type: "string", description: "New value for configAction=set." },
+      scope: {
+        type: "string",
+        enum: ["project", "global"],
+        description: "Settings scope to read or write. Defaults to project."
+      },
+      options: {
+        type: "object",
+        description: "Additional config options such as criterion, clearCriteria, format, or policy."
+      }
+    }, ["configAction"])
+  },
+  {
+    name: "pm_plan",
+    description: "Run agent-optimized Plan workflows. options.subcommand selects: create|show|add-step|update-step|complete-step|block-step|reorder-step|remove-step|link|unlink|decision|discovery|validation|resume|approve|materialize. Provide id for all non-create subcommands; provide stepRef for step lifecycle subcommands. Plans store agent-readable steps with dependencies, decisions, discoveries, validation, and resume context.",
+    inputSchema: objectSchema({
+      id: { type: "string", description: "Plan id (required for all subcommands except create)." },
+      stepRef: { type: "string", description: "Step id or order for step lifecycle subcommands." },
+      reorderTo: { type: "number", description: "New order for reorder-step." },
+      options: { type: "object", description: "Plan options including subcommand, stepRef, stepStatus, link, depth, etc." }
+    })
+  }
+];
+function buildMcpToolContracts() {
+  return TOOLS.map((tool) => {
+    const schemaRequired = tool.inputSchema["required"];
+    const required = Array.isArray(schemaRequired) ? schemaRequired.map((entry) => String(entry)).sort((left, right) => left.localeCompare(right)) : [];
+    return {
+      name: tool.name,
+      description: tool.description,
+      required,
+      input_schema: tool.inputSchema
+    };
+  }).sort((left, right) => left.name.localeCompare(right.name));
+}
+
+// dist/cli/commands/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] = "24d15738-45bd-5dd2-95e1-699f9c6061bd");
+  } catch (e2) {
+  }
+})();
+var LIST_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "list",
+  "list-all",
+  "list-draft",
+  "list-open",
+  "list-in-progress",
+  "list-blocked",
+  "list-closed",
+  "list-canceled"
+]);
+var PACKAGE_OWNED_ACTIONS = /* @__PURE__ */ new Set([
+  "calendar",
+  "dedupe-audit",
+  "dedupe-merge",
+  "guide",
+  "reindex",
+  "normalize",
+  "comments-audit",
+  "completion",
+  "test-runs-list",
+  "test-runs-status",
+  "test-runs-logs",
+  "test-runs-stop",
+  "test-runs-resume",
+  "templates-list",
+  "templates-save",
+  "templates-show"
+]);
+var PACKAGE_OWNED_COMMANDS = /* @__PURE__ */ new Set([
+  "cal",
+  "calendar",
+  "comments-audit",
+  "completion",
+  "completion-statuses",
+  "completion-tags",
+  "completion-types",
+  "dedupe-audit",
+  "dedupe-merge",
+  "guide",
+  "normalize",
+  "reindex",
+  "templates",
+  "templates list",
+  "templates save",
+  "templates show",
+  "test-runs",
+  "test-runs list",
+  "test-runs status",
+  "test-runs logs",
+  "test-runs stop",
+  "test-runs resume"
+]);
+var PACKAGE_OWNED_COMMAND_INSTALL_HINTS = /* @__PURE__ */ new Map([
+  ["cal", "calendar"],
+  ["calendar", "calendar"],
+  ["comments-audit", "governance-audit"],
+  ["completion", "guide-shell"],
+  ["completion-statuses", "guide-shell"],
+  ["completion-tags", "guide-shell"],
+  ["completion-types", "guide-shell"],
+  ["dedupe-audit", "governance-audit"],
+  ["dedupe-merge", "governance-audit"],
+  ["guide", "guide-shell"],
+  ["normalize", "governance-audit"],
+  ["reindex", "search-advanced"],
+  ["templates", "templates"],
+  ["templates list", "templates"],
+  ["templates save", "templates"],
+  ["templates show", "templates"],
+  ["test-runs", "linked-test-adapters"],
+  ["test-runs list", "linked-test-adapters"],
+  ["test-runs status", "linked-test-adapters"],
+  ["test-runs logs", "linked-test-adapters"],
+  ["test-runs stop", "linked-test-adapters"],
+  ["test-runs resume", "linked-test-adapters"]
+]);
+var PACKAGE_OWNED_ACTION_COMMAND_PATHS = /* @__PURE__ */ new Map([
+  ["calendar", "calendar|cal"],
+  ["dedupe-audit", "dedupe-audit"],
+  ["dedupe-merge", "dedupe-merge"],
+  ["guide", "guide"],
+  ["reindex", "reindex"],
+  ["normalize", "normalize"],
+  ["comments-audit", "comments-audit"],
+  ["completion", "completion"],
+  ["test-runs-list", "test-runs|test-runs list"],
+  ["test-runs-status", "test-runs status"],
+  ["test-runs-logs", "test-runs logs"],
+  ["test-runs-stop", "test-runs stop"],
+  ["test-runs-resume", "test-runs resume"],
+  ["templates-list", "templates|templates list"],
+  ["templates-save", "templates save"],
+  ["templates-show", "templates show"]
+]);
+var PACKAGE_OWNED_COMMAND_ACTIONS = new Map([...PACKAGE_OWNED_ACTION_COMMAND_PATHS.entries()].flatMap(([action, commandPaths]) => splitCommandPathAliases(commandPaths).map((commandPath) => [commandPath, action])));
+var CANONICAL_COMMAND_ALIASES = [
+  {
+    canonical: "context",
+    aliases: ["ctx"]
+  },
+  {
+    canonical: "package",
+    aliases: ["extension", "packages", "install"]
+  }
+];
+var COMMAND_ALIAS_TO_CANONICAL = new Map(CANONICAL_COMMAND_ALIASES.flatMap((entry) => entry.aliases.map((alias) => [alias, entry.canonical])));
+var COMMAND_NAMESPACE_DISPLAY_LIMIT = 10;
+var COMMAND_NAMESPACE_FALLBACK_LIMIT = 20;
+var EXTENSION_LIFECYCLE_FLAG_CONTRACTS = [
+  ["init", EXTENSION_INIT_FLAG_CONTRACTS],
+  ["install", EXTENSION_INSTALL_FLAG_CONTRACTS],
+  ["uninstall", EXTENSION_UNINSTALL_FLAG_CONTRACTS],
+  ["explore", EXTENSION_EXPLORE_FLAG_CONTRACTS],
+  ["manage", EXTENSION_MANAGE_FLAG_CONTRACTS],
+  ["describe", EXTENSION_DESCRIBE_FLAG_CONTRACTS],
+  ["reload", EXTENSION_RELOAD_FLAG_CONTRACTS],
+  ["doctor", EXTENSION_DOCTOR_FLAG_CONTRACTS],
+  ["catalog", EXTENSION_CATALOG_FLAG_CONTRACTS],
+  ["adopt", EXTENSION_ADOPT_FLAG_CONTRACTS],
+  ["adopt-all", EXTENSION_ADOPT_ALL_FLAG_CONTRACTS],
+  ["activate", EXTENSION_ACTIVATE_FLAG_CONTRACTS],
+  ["deactivate", EXTENSION_DEACTIVATE_FLAG_CONTRACTS]
+];
+var PACKAGE_LIFECYCLE_FLAG_CONTRACTS = EXTENSION_LIFECYCLE_FLAG_CONTRACTS.map(([subcommand, flags]) => subcommand === "init" ? [subcommand, PACKAGE_INIT_FLAG_CONTRACTS] : [subcommand, flags]);
+var CORE_COMMAND_FLAG_CONTRACT_ENTRIES = [
+  ...EXTENSION_LIFECYCLE_FLAG_CONTRACTS.map(([subcommand, flags]) => [`extension ${subcommand}`, flags]),
+  ...PACKAGE_LIFECYCLE_FLAG_CONTRACTS.flatMap(([subcommand, flags]) => [
+    [`package ${subcommand}`, flags],
+    [`packages ${subcommand}`, flags]
+  ]),
+  ["init", INIT_FLAG_CONTRACTS],
+  ["config", CONFIG_FLAG_CONTRACTS],
+  ["extension", EXTENSION_FLAG_CONTRACTS],
+  ["package", PACKAGE_FLAG_CONTRACTS],
+  ["packages", PACKAGE_FLAG_CONTRACTS],
+  ["install", INSTALL_FLAG_CONTRACTS],
+  ["create", CREATE_FLAG_CONTRACTS],
+  ["update", UPDATE_FLAG_CONTRACTS],
+  ["update-many", UPDATE_MANY_FLAG_CONTRACTS],
+  ["upgrade", UPGRADE_FLAG_CONTRACTS],
+  ["normalize", NORMALIZE_FLAG_CONTRACTS],
+  ["calendar", CALENDAR_FLAG_CONTRACTS],
+  ["cal", CALENDAR_FLAG_CONTRACTS],
+  ["context", CONTEXT_FLAG_CONTRACTS],
+  ["ctx", CONTEXT_FLAG_CONTRACTS],
+  ["get", GET_FLAG_CONTRACTS],
+  ["search", SEARCH_FLAG_CONTRACTS],
+  ["eval", EVAL_FLAG_CONTRACTS],
+  ["next", NEXT_FLAG_CONTRACTS],
+  ["aggregate", AGGREGATE_FLAG_CONTRACTS],
+  ["dedupe-audit", DEDUPE_AUDIT_FLAG_CONTRACTS],
+  ["dedupe-merge", DEDUPE_MERGE_FLAG_CONTRACTS],
+  ["deps", DEPS_FLAG_CONTRACTS],
+  ["guide", GUIDE_FLAG_CONTRACTS],
+  ["reindex", REINDEX_FLAG_CONTRACTS],
+  ["history", HISTORY_FLAG_CONTRACTS],
+  ["history-compact", HISTORY_COMPACT_FLAG_CONTRACTS],
+  ["history-redact", HISTORY_REDACT_FLAG_CONTRACTS],
+  ["history-repair", HISTORY_REPAIR_FLAG_CONTRACTS],
+  ["schema", SCHEMA_FLAG_CONTRACTS],
+  ["profile", PROFILE_FLAG_CONTRACTS],
+  ["plan", PLAN_FLAG_CONTRACTS],
+  ["restore", RESTORE_FLAG_CONTRACTS],
+  ["delete", DELETE_FLAG_CONTRACTS],
+  ["close", CLOSE_FLAG_CONTRACTS],
+  ["close-many", CLOSE_MANY_FLAG_CONTRACTS],
+  ["append", APPEND_FLAG_CONTRACTS],
+  ["claim", CLAIM_FLAG_CONTRACTS],
+  ["release", RELEASE_FLAG_CONTRACTS],
+  ["start-task", START_TASK_FLAG_CONTRACTS],
+  ["pause-task", PAUSE_TASK_FLAG_CONTRACTS],
+  ["close-task", CLOSE_TASK_FLAG_CONTRACTS],
+  ["comments", COMMENTS_FLAG_CONTRACTS],
+  ["notes", NOTES_FLAG_CONTRACTS],
+  ["learnings", LEARNINGS_FLAG_CONTRACTS],
+  ["files", FILES_FLAG_CONTRACTS],
+  ["docs", DOCS_FLAG_CONTRACTS],
+  ["test", TEST_FLAG_CONTRACTS],
+  ["test-all", TEST_ALL_FLAG_CONTRACTS],
+  ["telemetry", TELEMETRY_FLAG_CONTRACTS],
+  ["test-runs", TEST_RUNS_FLAG_CONTRACTS],
+  ["gc", GC_FLAG_CONTRACTS],
+  ["stats", STATS_FLAG_CONTRACTS],
+  ["validate", VALIDATE_FLAG_CONTRACTS],
+  ["comments-audit", COMMENTS_AUDIT_FLAG_CONTRACTS],
+  ["health", HEALTH_FLAG_CONTRACTS],
+  ["contracts", CONTRACTS_FLAG_CONTRACTS],
+  ["completion", COMPLETION_FLAG_CONTRACTS],
+  ["activity", ACTIVITY_FLAG_CONTRACTS],
+  ...[...LIST_COMMAND_NAMES].map((command) => [command, LIST_FILTER_FLAG_CONTRACTS])
+];
+var CORE_COMMAND_FLAG_CONTRACTS_BY_COMMAND = new Map(CORE_COMMAND_FLAG_CONTRACT_ENTRIES);
+function packageOwnedActionForCommand(command) {
+  const exactAction = PACKAGE_OWNED_COMMAND_ACTIONS.get(command);
+  if (exactAction) {
+    return exactAction;
+  }
+  if (command.startsWith("test-runs ")) {
+    return `test-runs-${command.slice("test-runs ".length)}`;
+  }
+  if (command.startsWith("templates ")) {
+    return `templates-${command.slice("templates ".length)}`;
+  }
+  return command;
+}
+function resolveActionCommandPath(action) {
+  if (PM_CORE_COMMAND_NAMES.includes(action)) {
+    return normalizeCommandPath(action);
+  }
+  if (action.startsWith("extension-")) {
+    return normalizeCommandPath(`extension ${action.slice("extension-".length)}`);
+  }
+  if (action.startsWith("package-")) {
+    return normalizeCommandPath(`package ${action.slice("package-".length)}`);
+  }
+  if (action.startsWith("test-runs-")) {
+    return normalizeCommandPath(`test-runs ${action.slice("test-runs-".length)}`);
+  }
+  if (action.startsWith("templates-")) {
+    return normalizeCommandPath(`templates ${action.slice("templates-".length)}`);
+  }
+  if (PACKAGE_OWNED_ACTIONS.has(action)) {
+    return PACKAGE_OWNED_ACTION_COMMAND_PATHS.get(action) ?? normalizeCommandPath(action);
+  }
+  return null;
+}
+function actionDescriptorMatchesSelectedCommand(descriptor, selectedCommand) {
+  if (descriptor.command_path === null) {
+    return false;
+  }
+  return splitCommandPathAliases(descriptor.command_path).some((commandPath) => {
+    if (commandPath === selectedCommand) {
+      return true;
+    }
+    return commandPath.startsWith(`${selectedCommand} `);
+  });
+}
+function splitCommandPathAliases(commandPath) {
+  return commandPath.split("|").map((entry) => normalizeCommandPath(entry)).filter((entry) => entry.length > 0);
+}
+function resolveScopedCommandsFromActionDescriptors(descriptors, commandCatalog) {
+  const commandSet = new Set(commandCatalog);
+  const scoped = /* @__PURE__ */ new Set();
+  for (const descriptor of descriptors) {
+    if (!descriptor.command_path) {
+      continue;
+    }
+    for (const commandPath of splitCommandPathAliases(descriptor.command_path)) {
+      const tokens = commandPath.split(" ").filter((entry) => entry.length > 0);
+      if (tokens.length === 0) {
+        continue;
+      }
+      for (let end = tokens.length; end > 0; end -= 1) {
+        const candidate = tokens.slice(0, end).join(" ");
+        if (!commandSet.has(candidate)) {
+          continue;
+        }
+        scoped.add(candidate);
+        break;
+      }
+    }
+  }
+  return [...scoped].sort((left, right) => left.localeCompare(right));
+}
+function normalizeToken(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim().toLowerCase();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function extractActionBranches(schema) {
+  const oneOf = schema.oneOf;
+  if (!Array.isArray(oneOf)) {
+    return [];
+  }
+  return oneOf.filter((entry) => typeof entry === "object" && entry !== null);
+}
+function filterSchemaByAction(schema, action) {
+  if (!action) {
+    return { ...schema };
+  }
+  const branches = extractActionBranches(schema);
+  const filtered = branches.filter((entry) => {
+    const properties = entry.properties;
+    if (typeof properties !== "object" || properties === null) {
+      return false;
+    }
+    const actionProperty = properties.action;
+    if (typeof actionProperty !== "object" || actionProperty === null) {
+      return false;
+    }
+    return actionProperty.const === action;
+  });
+  return {
+    ...schema,
+    oneOf: filtered
+  };
+}
+function filterSchemaByActions(schema, actions) {
+  const branches = extractActionBranches(schema);
+  const filtered = branches.filter((entry) => {
+    const properties = entry.properties;
+    if (typeof properties !== "object" || properties === null) {
+      return false;
+    }
+    const actionProperty = properties.action;
+    if (typeof actionProperty !== "object" || actionProperty === null) {
+      return false;
+    }
+    const actionConst = actionProperty.const;
+    return typeof actionConst === "string" && actions.has(actionConst);
+  });
+  return {
+    ...schema,
+    oneOf: filtered
+  };
+}
+function normalizeCommandPath(value) {
+  return value.trim().toLowerCase().split(/\s+/).filter((entry) => entry.length > 0).join(" ");
+}
+function normalizeActionNameFromCommand(commandPath) {
+  return commandPath.replace(/\s+/g, "-");
+}
+function toOptionalTrimmedString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeStringList(values) {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const trimmed = toOptionalTrimmedString(value);
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    normalized.push(trimmed);
+  }
+  return normalized;
+}
+function assignExtensionFlagBoolean(contract, key, enabled) {
+  if (enabled) {
+    contract[key] = true;
+  }
+}
+function toExtensionFlagContract(definition) {
+  const longName = toOptionalTrimmedString(definition.long);
+  const shortName = toOptionalTrimmedString(definition.short);
+  const normalizedLong = longName && longName.startsWith("--") && longName.length > 2 ? longName : null;
+  const normalizedShort = shortName && shortName.startsWith("-") && !shortName.startsWith("--") ? shortName : null;
+  const flag = normalizedLong ?? normalizedShort;
+  if (!flag) {
+    return null;
+  }
+  const contract = { flag };
+  if (normalizedShort && normalizedLong) {
+    contract.short = normalizedShort;
+  }
+  assignExtensionFlagBoolean(contract, "required", definition.required === true);
+  assignExtensionFlagBoolean(contract, "repeatable", definition.repeatable === true);
+  assignExtensionFlagBoolean(contract, "list", definition.list === true);
+  const description = toOptionalTrimmedString(definition.description);
+  if (description) {
+    contract.description = description;
+  }
+  const valueName = toOptionalTrimmedString(definition.value_name);
+  if (valueName) {
+    contract.value_name = valueName;
+  }
+  const rawValueType = [
+    toOptionalTrimmedString(definition.value_type),
+    toOptionalTrimmedString(definition.type),
+    valueName ? "string" : null
+  ].find((candidate) => candidate === "string" || candidate === "number" || candidate === "boolean");
+  if (rawValueType) {
+    contract.value_type = rawValueType;
+  }
+  return contract;
+}
+function collectExtensionFlagContractsByCommand(registrations) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const registration of registrations) {
+    const commandPath = normalizeCommandPath(registration.target_command);
+    if (commandPath.length === 0) {
+      continue;
+    }
+    const bucket = grouped.get(commandPath) ?? {
+      flags: [],
+      sources: [],
+      dedupe: /* @__PURE__ */ new Set(),
+      sourceDedupe: /* @__PURE__ */ new Set()
+    };
+    const sourceKey = `${registration.layer}:${registration.name}`;
+    if (!bucket.sourceDedupe.has(sourceKey)) {
+      bucket.sourceDedupe.add(sourceKey);
+      bucket.sources.push({
+        layer: registration.layer,
+        name: registration.name
+      });
+    }
+    for (const definition of registration.flags) {
+      const contract = toExtensionFlagContract(definition);
+      if (!contract) {
+        continue;
+      }
+      const key = `${contract.flag}|${contract.short ?? ""}`;
+      if (bucket.dedupe.has(key)) {
+        continue;
+      }
+      bucket.dedupe.add(key);
+      bucket.flags.push(contract);
+    }
+    grouped.set(commandPath, bucket);
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [commandPath, bucket] of grouped.entries()) {
+    normalized.set(commandPath, {
+      flags: bucket.flags,
+      sources: bucket.sources.sort((left, right) => {
+        const layerOrder = left.layer.localeCompare(right.layer);
+        if (layerOrder !== 0) {
+          return layerOrder;
+        }
+        return (left.name ?? "").localeCompare(right.name ?? "");
+      })
+    });
+  }
+  return normalized;
+}
+function collectExtensionCommandContracts(runtimeProbe) {
+  const flagsByCommand = collectExtensionFlagContractsByCommand(runtimeProbe.flagRegistrations);
+  const definitionsByCommand = /* @__PURE__ */ new Map();
+  for (const definition of runtimeProbe.commandDefinitions) {
+    const command = normalizeCommandPath(definition.command);
+    if (command.length === 0) {
+      continue;
+    }
+    const action = toOptionalTrimmedString(definition.action) ?? normalizeActionNameFromCommand(command);
+    const args = Array.isArray(definition.arguments) ? definition.arguments.map((argument) => {
+      const name = toOptionalTrimmedString(argument.name);
+      if (!name) {
+        return null;
+      }
+      return {
+        name,
+        required: argument.required === true,
+        variadic: argument.variadic === true,
+        description: toOptionalTrimmedString(argument.description)
+      };
+    }).filter((argument) => argument !== null) : [];
+    definitionsByCommand.set(command, {
+      command,
+      action,
+      source: {
+        layer: definition.layer,
+        name: definition.name
+      },
+      description: toOptionalTrimmedString(definition.description),
+      intent: toOptionalTrimmedString(definition.intent),
+      arguments: args,
+      flags: flagsByCommand.get(command)?.flags ?? [],
+      examples: normalizeStringList(definition.examples),
+      failure_hints: normalizeStringList(definition.failure_hints)
+    });
+  }
+  const extensionCommands = /* @__PURE__ */ new Set();
+  for (const command of runtimeProbe.handlers) {
+    extensionCommands.add(normalizeCommandPath(command));
+  }
+  for (const command of definitionsByCommand.keys()) {
+    extensionCommands.add(command);
+  }
+  for (const command of flagsByCommand.keys()) {
+    extensionCommands.add(command);
+  }
+  const contracts = [];
+  for (const command of [...extensionCommands].sort((left, right) => left.localeCompare(right))) {
+    const definition = definitionsByCommand.get(command);
+    if (definition) {
+      contracts.push({
+        ...definition,
+        flags: definition.flags.length > 0 ? definition.flags : flagsByCommand.get(command)?.flags ?? []
+      });
+      continue;
+    }
+    contracts.push({
+      command,
+      action: normalizeActionNameFromCommand(command),
+      source: null,
+      description: null,
+      intent: null,
+      arguments: [],
+      flags: flagsByCommand.get(command)?.flags ?? [],
+      examples: [],
+      failure_hints: []
+    });
+  }
+  return contracts;
+}
+function extensionSchemaPropertyNameFromFlag(flag) {
+  const normalized = flag.flag.replace(/^-+/, "").trim();
+  if (normalized.length === 0) {
+    return null;
+  }
+  const camelCased = normalized.replace(/-([a-z0-9])/g, (_match, char) => char.toUpperCase());
+  const cleaned = camelCased.replace(/[^a-zA-Z0-9]/g, "");
+  return cleaned.length > 0 ? cleaned : null;
+}
+function buildExtensionArgumentSchema(argument, action) {
+  if (argument.variadic) {
+    return {
+      type: "array",
+      items: { type: "string" },
+      description: argument.description ?? `Variadic argument '${argument.name}' for extension action '${action}'.`
+    };
+  }
+  return {
+    type: "string",
+    description: argument.description ?? `Argument '${argument.name}' for extension action '${action}'.`
+  };
+}
+function buildExtensionFlagSchema(flag, action) {
+  const valueType = flag.value_type ?? "boolean";
+  const schemaType = valueType === "boolean" ? "boolean" : valueType === "number" ? ["number", "string"] : "string";
+  const acceptsMultipleValues = flag.repeatable === true || flag.list === true;
+  return {
+    type: acceptsMultipleValues ? "array" : schemaType,
+    ...acceptsMultipleValues ? { items: { type: schemaType } } : {},
+    description: flag.description ?? `Extension option '${flag.flag}' for action '${action}'.`
+  };
+}
+function buildExtensionActionSchemaBranch(contract) {
+  const commands = contract.command.split("|").map((command) => command.trim()).filter((command) => command.length > 0);
+  const properties = {
+    action: {
+      type: "string",
+      const: contract.action,
+      description: contract.intent ?? contract.description ?? `Invoke extension command '${contract.command}'.`
+    }
+  };
+  const required = ["action"];
+  for (const argument of contract.arguments) {
+    properties[argument.name] = buildExtensionArgumentSchema(argument, contract.action);
+    if (argument.required) {
+      required.push(argument.name);
+    }
+  }
+  for (const flag of contract.flags) {
+    const propertyName = extensionSchemaPropertyNameFromFlag(flag);
+    if (!propertyName || properties[propertyName] !== void 0) {
+      continue;
+    }
+    properties[propertyName] = buildExtensionFlagSchema(flag, contract.action);
+    if (flag.required === true) {
+      required.push(propertyName);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required,
+    additionalProperties: true,
+    "x-extension-source": contract.source,
+    "x-extension-command": commands[0] ?? contract.command,
+    "x-extension-commands": commands
+  };
+}
+function mergeExtensionFlagContract(existing, incoming) {
+  existing.description ??= incoming.description;
+  existing.value_name ??= incoming.value_name;
+  existing.value_type ??= incoming.value_type;
+  if (incoming.required === true) {
+    existing.required = true;
+  }
+  if (incoming.repeatable === true) {
+    existing.repeatable = true;
+  }
+}
+function mergeExtensionContractsByAction(contracts) {
+  const byAction = /* @__PURE__ */ new Map();
+  for (const contract of contracts) {
+    const existing = byAction.get(contract.action);
+    if (!existing) {
+      byAction.set(contract.action, {
+        ...contract,
+        flags: [...contract.flags],
+        examples: [...contract.examples],
+        failure_hints: [...contract.failure_hints]
+      });
+      continue;
+    }
+    existing.command = [.../* @__PURE__ */ new Set([existing.command, contract.command])].sort((left, right) => left.localeCompare(right)).join("|");
+    existing.arguments = existing.arguments.length >= contract.arguments.length ? existing.arguments : contract.arguments;
+    const flagKeys = new Set(existing.flags.map((flag) => `${flag.flag}|${flag.short ?? ""}`));
+    for (const flag of contract.flags) {
+      const key = `${flag.flag}|${flag.short ?? ""}`;
+      if (!flagKeys.has(key)) {
+        flagKeys.add(key);
+        existing.flags.push(flag);
+      } else {
+        const existingFlag = existing.flags.find((candidate) => `${candidate.flag}|${candidate.short ?? ""}` === key);
+        if (existingFlag) {
+          mergeExtensionFlagContract(existingFlag, flag);
+        }
+      }
+    }
+    existing.examples = [.../* @__PURE__ */ new Set([...existing.examples, ...contract.examples])];
+    existing.failure_hints = [.../* @__PURE__ */ new Set([...existing.failure_hints, ...contract.failure_hints])];
+  }
+  return [...byAction.values()].sort((left, right) => left.action.localeCompare(right.action));
+}
+async function resolveRuntimeExtensionActionProbe(global2) {
+  const defaultPolicyState = {
+    mode: SETTINGS_DEFAULTS.extensions.policy.mode,
+    trust_mode: SETTINGS_DEFAULTS.extensions.policy.trust_mode,
+    default_sandbox_profile: SETTINGS_DEFAULTS.extensions.policy.default_sandbox_profile
+  };
+  if (global2.noExtensions) {
+    return {
+      handlers: /* @__PURE__ */ new Set(),
+      disabledReason: "extensions_disabled",
+      commandDefinitions: [],
+      flagRegistrations: [],
+      registrations: null,
+      policyState: defaultPolicyState
+    };
+  }
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    return {
+      handlers: /* @__PURE__ */ new Set(),
+      disabledReason: null,
+      commandDefinitions: [],
+      flagRegistrations: [],
+      registrations: null,
+      policyState: defaultPolicyState
+    };
+  }
+  try {
+    const settings = await readSettings(pmRoot);
+    const loadResult = await loadExtensions({
+      pmRoot,
+      settings,
+      cwd: process.cwd(),
+      noExtensions: false
+    });
+    const activationResult = await activateExtensions({
+      ...loadResult,
+      loaded: loadResult.loaded
+    });
+    const handlers = new Set(activationResult.commands.handlers.map((entry) => normalizeCommandPath(entry.command)));
+    return {
+      handlers,
+      disabledReason: null,
+      commandDefinitions: activationResult.registrations.commands,
+      flagRegistrations: activationResult.registrations.flags,
+      registrations: activationResult.registrations,
+      policyState: {
+        mode: loadResult.policy.mode,
+        trust_mode: loadResult.policy.trust_mode,
+        default_sandbox_profile: loadResult.policy.default_sandbox_profile
+      }
+    };
+  } catch {
+    return {
+      handlers: /* @__PURE__ */ new Set(),
+      disabledReason: "extension_runtime_probe_failed",
+      commandDefinitions: [],
+      flagRegistrations: [],
+      registrations: null,
+      policyState: defaultPolicyState
+    };
+  }
+}
+function collectActionContractDescriptors(extensionContracts, options = {}) {
+  const descriptors = /* @__PURE__ */ new Map();
+  for (const action of PM_TOOL_ACTIONS) {
+    const packageOwned = PACKAGE_OWNED_ACTIONS.has(action);
+    if (packageOwned && !options.includePackageOwnedActions) {
+      continue;
+    }
+    const commandPath = resolveActionCommandPath(action);
+    descriptors.set(action, {
+      action,
+      provider: packageOwned ? "extension" : "core",
+      requires_extension: packageOwned,
+      command_path: commandPath
+    });
+  }
+  if (options.includePackageOwnedActions) {
+    for (const action of PACKAGE_OWNED_ACTIONS) {
+      if (descriptors.has(action)) {
+        continue;
+      }
+      descriptors.set(action, {
+        action,
+        provider: "extension",
+        requires_extension: true,
+        command_path: resolveActionCommandPath(action)
+      });
+    }
+  }
+  for (const contract of extensionContracts) {
+    if (descriptors.has(contract.action)) {
+      continue;
+    }
+    descriptors.set(contract.action, {
+      action: contract.action,
+      provider: "extension",
+      requires_extension: true,
+      command_path: normalizeCommandPath(contract.command)
+    });
+  }
+  return [...descriptors.values()].sort((left, right) => (left.action ?? "").localeCompare(right.action ?? ""));
+}
+function resolveActionAvailability(descriptor, runtimeProbe) {
+  if (descriptor.provider === "core" && !descriptor.requires_extension) {
+    return {
+      action: descriptor.action,
+      invocable: true,
+      available: true,
+      requires_extension: false,
+      provider: "core",
+      disabled_reason: null,
+      command_path: descriptor.command_path,
+      cli_exposed: descriptor.command_path !== null
+    };
+  }
+  const commandPaths = descriptor.command_path ? splitCommandPathAliases(descriptor.command_path) : [];
+  const extensionCommandAvailable = commandPaths.some((commandPath) => runtimeProbe.handlers.has(commandPath));
+  const optionalPackageHint = commandPaths.map((commandPath) => PACKAGE_OWNED_COMMAND_INSTALL_HINTS.get(commandPath)).find((hint) => typeof hint === "string");
+  const invocable = runtimeProbe.disabledReason === null && extensionCommandAvailable;
+  return {
+    action: descriptor.action,
+    invocable,
+    available: invocable,
+    requires_extension: true,
+    provider: "extension",
+    disabled_reason: invocable ? null : runtimeProbe.disabledReason ?? (optionalPackageHint ? `optional_package_not_installed:${optionalPackageHint}` : "extension_command_not_registered"),
+    command_path: descriptor.command_path,
+    cli_exposed: extensionCommandAvailable,
+    policy_state: {
+      mode: runtimeProbe.policyState.mode,
+      trust_mode: runtimeProbe.policyState.trust_mode,
+      default_sandbox_profile: runtimeProbe.policyState.default_sandbox_profile
+    }
+  };
+}
+function resolveCoreCommandFlags(command) {
+  return CORE_COMMAND_FLAG_CONTRACTS_BY_COMMAND.get(command) ?? GLOBAL_FLAG_CONTRACTS;
+}
+function isCoreCommandPath(command) {
+  if (PACKAGE_OWNED_COMMANDS.has(command)) {
+    return false;
+  }
+  return CORE_COMMAND_FLAG_CONTRACTS_BY_COMMAND.has(command);
+}
+function normalizeCommandForRuntimeFieldFlags(command) {
+  if (LIST_COMMAND_NAMES.has(command)) {
+    return "list";
+  }
+  if (command === "cal") {
+    return "calendar";
+  }
+  if (command === "ctx") {
+    return "context";
+  }
+  if (command === "update-many") {
+    return "update_many";
+  }
+  return command;
+}
+function toRuntimeLongFlagToken(token) {
+  const trimmed = token.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("--")) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("-")) {
+    return null;
+  }
+  return `--${trimmed}`;
+}
+function toRuntimeShortFlagToken(token) {
+  const trimmed = token.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("--")) {
+    return null;
+  }
+  if (trimmed.startsWith("-")) {
+    return trimmed;
+  }
+  return null;
+}
+function buildRuntimeFieldFlagContracts(fieldRegistry) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const definition of fieldRegistry.definitions) {
+    const primaryFlag = toRuntimeLongFlagToken(definition.cli_flag);
+    if (!primaryFlag) {
+      continue;
+    }
+    const shortAlias = definition.cli_aliases.map((alias) => toRuntimeShortFlagToken(alias)).find((alias) => alias !== null);
+    const longAliases = definition.cli_aliases.map((alias) => toRuntimeLongFlagToken(alias)).filter((alias) => alias !== null && alias !== primaryFlag);
+    for (const command of definition.commands) {
+      const bucket = buckets.get(command) ?? {
+        flags: [],
+        seen: /* @__PURE__ */ new Set()
+      };
+      const primaryContract = shortAlias ? { flag: primaryFlag, short: shortAlias } : { flag: primaryFlag };
+      const primaryKey = `${primaryContract.flag}|${primaryContract.short ?? ""}`;
+      if (!bucket.seen.has(primaryKey)) {
+        bucket.seen.add(primaryKey);
+        bucket.flags.push(primaryContract);
+      }
+      for (const alias of longAliases) {
+        const key = `${alias}|`;
+        if (bucket.seen.has(key)) {
+          continue;
+        }
+        bucket.seen.add(key);
+        bucket.flags.push({ flag: alias });
+      }
+      buckets.set(command, bucket);
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [command, bucket] of buckets.entries()) {
+    result.set(command, compactFlagAliasContracts(bucket.flags));
+  }
+  return result;
+}
+function mergeFlagContracts(primary, secondary) {
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const contract of [...primary, ...secondary]) {
+    const key = `${contract.flag}|${contract.short ?? ""}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(contract);
+  }
+  return compactFlagAliasContracts(merged);
+}
+function buildCommandFlagSurface(commands, extensionFlagMap, runtimeFieldFlagMap) {
+  return commands.map((command) => {
+    const isCoreCommand = isCoreCommandPath(command);
+    const coreFlags = isCoreCommand ? resolveCoreCommandFlags(command) : [];
+    const runtimeFlags = runtimeFieldFlagMap.get(normalizeCommandForRuntimeFieldFlags(command)) ?? [];
+    const extensionFlags = extensionFlagMap.get(command);
+    const coreWithRuntime = mergeFlagContracts(coreFlags, runtimeFlags);
+    const flags = mergeFlagContracts(coreWithRuntime, extensionFlags?.flags ?? []);
+    const provider = coreFlags.length > 0 && (extensionFlags?.flags.length ?? 0) > 0 ? "mixed" : isCoreCommand ? "core" : "extension";
+    return {
+      command,
+      flags,
+      provider,
+      extension_sources: extensionFlags?.sources
+    };
+  }).sort((left, right) => left.command.localeCompare(right.command));
+}
+function compactCommandAliasSurface(commands) {
+  const commandSet = new Set(commands);
+  const result = [];
+  for (const command of commands) {
+    const canonical = COMMAND_ALIAS_TO_CANONICAL.get(command);
+    if (canonical && commandSet.has(canonical)) {
+      continue;
+    }
+    result.push(command);
+  }
+  return result;
+}
+function buildCommandAliasSurface(commands) {
+  const commandSet = new Set(commands);
+  return CANONICAL_COMMAND_ALIASES.map((entry) => ({
+    canonical: entry.canonical,
+    aliases: entry.aliases.filter((alias) => commandSet.has(alias))
+  })).filter((entry) => commandSet.has(entry.canonical) && entry.aliases.length > 0);
+}
+function buildCommanderAliasSurface() {
+  return {
+    create_string_options: CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
+    create_repeatable_options: CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+    update_string_options: UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
+    update_repeatable_options: UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
+    list_string_options: LIST_COMMANDER_STRING_OPTION_CONTRACTS,
+    search_string_options: SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
+    calendar_string_options: CALENDAR_COMMANDER_STRING_OPTION_CONTRACTS,
+    context_string_options: CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
+    activity_string_options: ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS
+  };
+}
+function resolveCreateRequiredOptionContract(typeDefinition, createMode) {
+  const baseRequiredOptions = /* @__PURE__ */ new Set(["title", "type"]);
+  if (createMode === "strict") {
+    for (const field of typeDefinition.required_create_fields) {
+      baseRequiredOptions.add(field);
+    }
+    for (const field of typeDefinition.required_create_repeatables) {
+      baseRequiredOptions.add(field);
+    }
+  }
+  const policyState = resolveCommandOptionPolicyState(typeDefinition, "create", baseRequiredOptions);
+  const requiredOptionKeys = [...new Set(policyState.required)].sort((left, right) => left.localeCompare(right));
+  const requiredFlags = [
+    ...new Set(requiredOptionKeys.map((option) => commandOptionFlagLabel("create", option)))
+  ].sort((left, right) => left.localeCompare(right));
+  const requiredTypeOptions = [
+    ...new Set(typeDefinition.options.filter((option) => option.required === true).map((option) => option.key))
+  ].sort((left, right) => left.localeCompare(right));
+  return {
+    required_option_keys: requiredOptionKeys,
+    required_flags: requiredFlags,
+    required_type_options: requiredTypeOptions,
+    policy_errors: [...new Set(policyState.errors)].sort((left, right) => left.localeCompare(right))
+  };
+}
+function buildCreateRequiredOptionContracts(typeRegistry) {
+  const byTypeStrict = {};
+  const byTypeProgressive = {};
+  for (const typeName of [...typeRegistry.types].sort((left, right) => left.localeCompare(right))) {
+    const typeDefinition = typeRegistry.by_type[typeName];
+    byTypeStrict[typeName] = resolveCreateRequiredOptionContract(typeDefinition, "strict");
+    byTypeProgressive[typeName] = resolveCreateRequiredOptionContract(typeDefinition, "progressive");
+  }
+  return {
+    default_create_mode: "strict",
+    by_create_mode: {
+      strict: {
+        by_type: byTypeStrict
+      },
+      progressive: {
+        by_type: byTypeProgressive
+      }
+    }
+  };
+}
+function attachCreateRequiredOptionContracts(schema, metadata) {
+  const branches = extractActionBranches(schema);
+  if (branches.length === 0) {
+    return schema;
+  }
+  let touched = false;
+  const enrichedBranches = branches.map((branch) => {
+    const properties = branch.properties;
+    if (typeof properties !== "object" || properties === null) {
+      return branch;
+    }
+    const actionProperty = properties.action;
+    if (typeof actionProperty !== "object" || actionProperty === null) {
+      return branch;
+    }
+    if (actionProperty.const !== "create") {
+      return branch;
+    }
+    touched = true;
+    return {
+      ...branch,
+      "x-create-required-options": metadata
+    };
+  });
+  if (!touched) {
+    return schema;
+  }
+  return {
+    ...schema,
+    oneOf: enrichedBranches
+  };
+}
+function resolveContractsSelection(options) {
+  const schemaOnly = options.schemaOnly === true;
+  const flagsOnly = options.flagsOnly === true;
+  const availabilityOnly = options.availabilityOnly === true;
+  const runtimeOnly = options.runtimeOnly === true;
+  const fullOutput = options.full === true;
+  const selectedAction = normalizeToken(options.action);
+  const selectedCommand = normalizeToken(options.command);
+  const unfilteredDefaultBriefMode = !fullOutput && !schemaOnly && !flagsOnly && !availabilityOnly && !selectedAction && !selectedCommand;
+  return {
+    selectedAction,
+    selectedCommand,
+    schemaOnly,
+    flagsOnly,
+    availabilityOnly,
+    runtimeOnly,
+    fullOutput,
+    omitUnfilteredSchema: unfilteredDefaultBriefMode,
+    omitUnfilteredCommandFlags: unfilteredDefaultBriefMode,
+    omitUnfilteredCommanderAliases: unfilteredDefaultBriefMode
+  };
+}
+function assertSingleContractsProjection(selection) {
+  const projectionFlagsEnabled = [
+    selection.schemaOnly,
+    selection.flagsOnly,
+    selection.availabilityOnly
+  ].filter((value) => value).length;
+  if (projectionFlagsEnabled > 1) {
+    throw new PmCliError("Choose only one projection flag: --schema-only, --flags-only, or --availability-only.", EXIT_CODE.USAGE);
+  }
+}
+async function readContractsSettings(pmRoot) {
+  try {
+    return await readSettings(pmRoot);
+  } catch {
+    return structuredClone(SETTINGS_DEFAULTS);
+  }
+}
+async function resolveContractsRuntimeContext(global2, pmRoot) {
+  const settings = await readContractsSettings(pmRoot);
+  const runtimeProbe = await resolveRuntimeExtensionActionProbe(global2);
+  const typeRegistry = resolveItemTypeRegistry(settings, runtimeProbe.registrations ?? getActiveExtensionRegistrations());
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const extensionContracts = collectExtensionCommandContracts(runtimeProbe);
+  return {
+    settings,
+    runtimeProbe,
+    typeRegistry,
+    statusRegistry: resolveRuntimeStatusRegistry(settings.schema),
+    runtimeFieldRegistry,
+    runtimeFieldFlagMap: buildRuntimeFieldFlagContracts(runtimeFieldRegistry),
+    createRequiredOptionContracts: buildCreateRequiredOptionContracts(typeRegistry),
+    extensionContracts,
+    mergedExtensionContracts: mergeExtensionContractsByAction(extensionContracts),
+    extensionFlagMap: collectExtensionFlagContractsByCommand(runtimeProbe.flagRegistrations)
+  };
+}
+function shouldIncludePackageOwnedActions(selection) {
+  return selection.availabilityOnly && (selection.selectedAction !== void 0 && PACKAGE_OWNED_ACTIONS.has(selection.selectedAction) || selection.selectedCommand !== void 0 && PACKAGE_OWNED_COMMANDS.has(selection.selectedCommand));
+}
+function collectContractsActionDescriptors(selection, mergedExtensionContracts) {
+  const actionDescriptors = collectActionContractDescriptors(mergedExtensionContracts, {
+    includePackageOwnedActions: shouldIncludePackageOwnedActions(selection)
+  });
+  if (shouldIncludePackageOwnedActions(selection) && selection.selectedCommand !== void 0 && PACKAGE_OWNED_COMMANDS.has(selection.selectedCommand) && !actionDescriptors.some((entry) => entry.command_path === selection.selectedCommand)) {
+    actionDescriptors.push({
+      action: packageOwnedActionForCommand(selection.selectedCommand),
+      provider: "extension",
+      requires_extension: true,
+      command_path: selection.selectedCommand
+    });
+  }
+  return actionDescriptors;
+}
+function assertKnownContractsAction(selection, actionDescriptors) {
+  const actionNames = new Set(actionDescriptors.map((entry) => entry.action));
+  if (selection.selectedAction && !actionNames.has(selection.selectedAction)) {
+    throw new PmCliError(`Unknown action: "${selection.selectedAction}".`, EXIT_CODE.USAGE);
+  }
+}
+function buildContractsCommandCatalog(actionDescriptors, mergedExtensionContracts) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...PM_CORE_COMMAND_NAMES.filter((entry) => !PACKAGE_OWNED_COMMANDS.has(entry)),
+      ...[...CORE_COMMAND_FLAG_CONTRACTS_BY_COMMAND.keys()].filter((entry) => !PACKAGE_OWNED_COMMANDS.has(entry)),
+      /* c8 ignore next -- action descriptors always include concrete command paths in command-scoped test fixtures. */
+      ...actionDescriptors.flatMap((entry) => entry.command_path ? splitCommandPathAliases(entry.command_path) : []),
+      ...mergedExtensionContracts.flatMap((entry) => entry.command.split("|"))
+    ])
+  ].map((entry) => normalizeCommandPath(entry)).filter((entry) => entry.length > 0).sort((left, right) => left.localeCompare(right));
+}
+function buildCommandNamespaceError(command, namespaceChildren) {
+  const displayedNamespaceChildren = namespaceChildren.slice(0, COMMAND_NAMESPACE_DISPLAY_LIMIT);
+  const hiddenNamespaceChildCount = namespaceChildren.length - displayedNamespaceChildren.length;
+  const displayedChildCommandList = hiddenNamespaceChildCount > 0 ? `${displayedNamespaceChildren.join(", ")}, and ${hiddenNamespaceChildCount} more` : displayedNamespaceChildren.join(", ");
+  const fallbackCandidates = namespaceChildren.slice(0, COMMAND_NAMESPACE_FALLBACK_LIMIT);
+  const childCommandExamples = namespaceChildren.slice(0, 5).map((childCommand) => `pm contracts --command "${childCommand}" --flags-only --json`);
+  const suggestedChildCommand = namespaceChildren[0];
+  return new PmCliError(`Command "${command}" is a command namespace. Choose a concrete child command: ${displayedChildCommandList}.`, EXIT_CODE.USAGE, {
+    code: "command_namespace",
+    required: "Use a concrete child command path listed under this namespace.",
+    why: "Command groups expose help at the namespace root, but command flag contracts belong to executable child commands.",
+    examples: childCommandExamples,
+    nextSteps: [`Retry with a child command, for example: ${childCommandExamples[0]}`],
+    recovery: {
+      suggested_retry: `pm contracts --command "${suggestedChildCommand}" --flags-only --json`,
+      fallback_candidates: fallbackCandidates.map((childCommand) => ({
+        source: "command_namespace",
+        command: `pm contracts --command "${childCommand}" --flags-only --json`,
+        reason: `Child command under ${command}`
+      }))
+    }
+  });
+}
+function buildPackageOwnedCommandError(command, packageHint) {
+  return new PmCliError(`Unknown command: "${command}". Command "${command}" is provided by the optional "${packageHint}" package. Run "pm install ${packageHint} --project" and retry.`, EXIT_CODE.USAGE, {
+    code: "unknown_command",
+    required: `Install the optional "${packageHint}" package, or choose a command from pm contracts --flags-only --json.`,
+    why: "Command contracts include core commands plus commands registered by active packages and extensions.",
+    examples: [`pm install ${packageHint} --project`, `pm contracts --command ${command} --flags-only --json`],
+    nextSteps: [`Install the optional package first: pm install ${packageHint} --project`],
+    recovery: {
+      suggested_retry: `pm install ${packageHint} --project`
+    }
+  });
+}
+function buildUnknownCommandError(command) {
+  return new PmCliError(`Unknown command: "${command}".`, EXIT_CODE.USAGE, {
+    code: "unknown_command",
+    required: "Use a command path listed by pm contracts --flags-only --json.",
+    why: "Command contracts are generated from the active core, package, and extension command registry.",
+    examples: ["pm contracts --flags-only --json", "pm --help"],
+    nextSteps: ["Verify spelling and active packages/extensions, then rerun with a known command path."],
+    recovery: {
+      suggested_retry: "pm contracts --flags-only --json"
+    }
+  });
+}
+function assertKnownContractsCommand(selection, commandCatalog) {
+  if (!selection.selectedCommand) {
+    return;
+  }
+  const commandNames = new Set(commandCatalog);
+  if (commandNames.has(selection.selectedCommand)) {
+    return;
+  }
+  const namespaceChildren = commandCatalog.filter((command) => command.startsWith(`${selection.selectedCommand} `));
+  if (namespaceChildren.length > 0) {
+    throw buildCommandNamespaceError(selection.selectedCommand, namespaceChildren);
+  }
+  const packageHint = PACKAGE_OWNED_COMMAND_INSTALL_HINTS.get(selection.selectedCommand);
+  if (packageHint) {
+    throw buildPackageOwnedCommandError(selection.selectedCommand, packageHint);
+  }
+  throw buildUnknownCommandError(selection.selectedCommand);
+}
+function resolveContractsActionContext(selection, runtime) {
+  const actionDescriptors = collectContractsActionDescriptors(selection, runtime.mergedExtensionContracts);
+  assertKnownContractsAction(selection, actionDescriptors);
+  const commandCatalog = buildContractsCommandCatalog(actionDescriptors, runtime.mergedExtensionContracts);
+  assertKnownContractsCommand(selection, commandCatalog);
+  const selectedPackageOwnedAction = selection.selectedCommand ? PACKAGE_OWNED_COMMAND_ACTIONS.get(selection.selectedCommand) : void 0;
+  const commandScopedDescriptors = selection.selectedCommand ? actionDescriptors.filter((descriptor) => selectedPackageOwnedAction ? descriptor.action === selectedPackageOwnedAction : actionDescriptorMatchesSelectedCommand(descriptor, selection.selectedCommand)) : actionDescriptors;
+  if (selection.selectedCommand && selection.selectedAction && !commandScopedDescriptors.some((descriptor) => descriptor.action === selection.selectedAction)) {
+    throw new PmCliError(`Action "${selection.selectedAction}" is not mapped to command "${selection.selectedCommand}" in contracts output.`, EXIT_CODE.USAGE);
+  }
+  const scopedActionDescriptors = selection.selectedAction ? commandScopedDescriptors.filter((descriptor) => descriptor.action === selection.selectedAction) : commandScopedDescriptors;
+  const allActionAvailability = [
+    ...new Map(scopedActionDescriptors.map((descriptor) => resolveActionAvailability(descriptor, runtime.runtimeProbe)).map((entry) => [
+      /* c8 ignore next -- keyed dedupe by action|path is covered by runtime policy integration tests. */
+      selectedPackageOwnedAction ? entry.action : `${entry.action}|${entry.command_path ?? ""}`,
+      entry
+    ])).values()
+  ];
+  const actionAvailability = selection.runtimeOnly && !selection.selectedAction && !selection.availabilityOnly ? allActionAvailability.filter((entry) => entry.invocable) : allActionAvailability;
+  return {
+    actionDescriptors,
+    commandCatalog,
+    commandScopedDescriptors,
+    scopedActionDescriptors,
+    selectedPackageOwnedAction,
+    actionAvailability,
+    actions: [...new Set(actionAvailability.map((entry) => entry.action))]
+  };
+}
+function buildSchemaActionSet(schema) {
+  return new Set(extractActionBranches(schema).map((entry) => {
+    const properties = entry.properties;
+    if (typeof properties !== "object" || properties === null) {
+      return null;
+    }
+    const actionProperty = properties.action;
+    if (typeof actionProperty !== "object" || actionProperty === null) {
+      return null;
+    }
+    const actionConst = actionProperty.const;
+    return typeof actionConst === "string" ? actionConst : null;
+  }).filter((entry) => entry !== null));
+}
+function buildMergedContractsSchema(mergedExtensionContracts) {
+  const schema = PM_TOOL_PARAMETERS_SCHEMA;
+  const schemaBranches = extractActionBranches(schema);
+  const schemaActionSet = buildSchemaActionSet(schema);
+  const extensionBranches = mergedExtensionContracts.filter((contract) => !schemaActionSet.has(contract.action)).map((contract) => buildExtensionActionSchemaBranch(contract));
+  return extensionBranches.length > 0 ? {
+    ...schema,
+    oneOf: [...schemaBranches, ...extensionBranches]
+  } : schema;
+}
+function filterContractsSchema(selection, actionContext, mergedSchema) {
+  const descriptorActionSet = new Set(actionContext.actionDescriptors.map((descriptor) => descriptor.action));
+  const filteredSchema = selection.selectedAction ? filterSchemaByAction(mergedSchema, selection.selectedAction) : selection.selectedCommand ? filterSchemaByActions(mergedSchema, new Set(actionContext.scopedActionDescriptors.map((descriptor) => descriptor.action))) : filterSchemaByActions(mergedSchema, descriptorActionSet);
+  return selection.runtimeOnly && !selection.selectedAction ? filterSchemaByActions(filteredSchema, new Set(actionContext.actions)) : filteredSchema;
+}
+function resolveContractsSchemaContext(selection, runtime, actionContext) {
+  const mergedSchema = buildMergedContractsSchema(runtime.mergedExtensionContracts);
+  const includeSchemaSurface = !selection.flagsOnly && !selection.availabilityOnly;
+  const filteredSchema = includeSchemaSurface ? attachCreateRequiredOptionContracts(filterContractsSchema(selection, actionContext, mergedSchema), runtime.createRequiredOptionContracts) : filterContractsSchema(selection, actionContext, mergedSchema);
+  return { mergedSchema, filteredSchema };
+}
+function resolveContractsCommands(selection, actionContext) {
+  if (selection.selectedCommand !== void 0) {
+    return [selection.selectedCommand];
+  }
+  if (selection.selectedAction) {
+    return resolveScopedCommandsFromActionDescriptors(actionContext.scopedActionDescriptors, actionContext.commandCatalog);
+  }
+  return actionContext.commandCatalog;
+}
+function resolveOutputCommands(selection, commands) {
+  return selection.flagsOnly && selection.selectedCommand === void 0 && selection.selectedAction === void 0 ? compactCommandAliasSurface(commands) : commands;
+}
+function resolveExtensionCommandContracts(selection, runtime, outputCommands) {
+  if (selection.selectedCommand) {
+    return runtime.extensionContracts.filter((entry) => splitCommandPathAliases(entry.command).includes(selection.selectedCommand));
+  }
+  if (selection.selectedAction) {
+    const outputCommandSet = new Set(outputCommands);
+    return runtime.extensionContracts.filter((entry) => splitCommandPathAliases(entry.command).some((command) => outputCommandSet.has(command)));
+  }
+  return runtime.extensionContracts;
+}
+function createContractsResult(selection, schemaContext, actionContext, outputCommands) {
+  return {
+    schema_version: (
+      /* c8 ignore next -- schema version/id fallbacks are exercised by schema snapshot tests. */
+      typeof schemaContext.mergedSchema["x-schema-version"] === "string" ? schemaContext.mergedSchema["x-schema-version"] : null
+    ),
+    schema_id: (
+      /* c8 ignore next -- schema version/id fallbacks are exercised by schema snapshot tests. */
+      typeof schemaContext.mergedSchema.$id === "string" ? schemaContext.mergedSchema.$id : null
+    ),
+    selected: {
+      action: selection.selectedAction ?? null,
+      command: selection.selectedCommand ?? null,
+      schema_only: selection.schemaOnly,
+      flags_only: selection.flagsOnly,
+      availability_only: selection.availabilityOnly,
+      runtime_only: selection.runtimeOnly,
+      command_scoped: selection.selectedCommand !== void 0
+    },
+    commands: outputCommands,
+    ...!selection.flagsOnly ? {
+      actions: actionContext.actions,
+      action_availability: actionContext.actionAvailability
+    } : {}
+  };
+}
+function attachRuntimeContractsResult(result, runtime) {
+  result.runtime_schema = {
+    statuses: runtime.statusRegistry.definitions.map((definition) => definition.id),
+    open_status: runtime.statusRegistry.open_status,
+    close_status: runtime.statusRegistry.close_status,
+    canceled_status: runtime.statusRegistry.canceled_status,
+    types: [...runtime.typeRegistry.types],
+    fields_by_command: Object.fromEntries([...runtime.runtimeFieldRegistry.command_to_fields.entries()].map(([command, definitions]) => [
+      command,
+      [...new Set(definitions.map((definition) => `--${definition.cli_flag}`))].sort((left, right) => left.localeCompare(right))
+    ]))
+  };
+  result.extension_contracts = {
+    capabilities: [...PM_EXTENSION_CAPABILITY_CONTRACTS],
+    services: [...PM_EXTENSION_SERVICE_NAME_CONTRACTS],
+    policy_modes: [...PM_EXTENSION_POLICY_MODE_CONTRACTS],
+    policy_surfaces: [...PM_EXTENSION_POLICY_SURFACE_CONTRACTS],
+    trust_modes: [...PM_EXTENSION_TRUST_MODE_CONTRACTS],
+    sandbox_profiles: [...PM_EXTENSION_SANDBOX_PROFILE_CONTRACTS],
+    manifest_versions: [1, 2],
+    compatibility: {
+      current: "v2",
+      previous: ["v1"],
+      breaking_strategy: "versioned_breaking"
+    }
+  };
+}
+function attachSchemaContractsResult(result, selection, schemaContext, extensionCommandContracts) {
+  if (selection.flagsOnly || selection.availabilityOnly) {
+    return;
+  }
+  if (!selection.omitUnfilteredSchema) {
+    result.schema = schemaContext.filteredSchema;
+    result.extension_commands = extensionCommandContracts;
+    return;
+  }
+  result.schema_omitted_reason = "unfiltered_default_brief";
+  result.extension_commands = extensionCommandContracts;
+}
+function attachFlagContractsResult(result, selection, runtime, outputCommands, commandAliases) {
+  if (selection.schemaOnly || selection.availabilityOnly) {
+    return;
+  }
+  if (!selection.omitUnfilteredCommandFlags) {
+    result.command_flags = buildCommandFlagSurface(outputCommands, runtime.extensionFlagMap, runtime.runtimeFieldFlagMap);
+  } else {
+    result.command_flags_omitted_reason = "unfiltered_default_brief";
+  }
+  if (commandAliases.length > 0) {
+    result.command_aliases = commandAliases;
+  }
+}
+function attachCommanderAliasContractsResult(result, selection) {
+  if (selection.schemaOnly || selection.flagsOnly || selection.availabilityOnly) {
+    return;
+  }
+  if (!selection.omitUnfilteredCommanderAliases) {
+    result.commander_aliases = buildCommanderAliasSurface();
+    return;
+  }
+  result.commander_aliases_omitted_reason = "unfiltered_default_brief";
+}
+async function runContracts(options, global2) {
+  const selection = resolveContractsSelection(options);
+  assertSingleContractsProjection(selection);
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  const runtime = await resolveContractsRuntimeContext(global2, pmRoot);
+  const actionContext = resolveContractsActionContext(selection, runtime);
+  const schemaContext = resolveContractsSchemaContext(selection, runtime, actionContext);
+  const commands = resolveContractsCommands(selection, actionContext);
+  const outputCommands = resolveOutputCommands(selection, commands);
+  const commandAliases = buildCommandAliasSurface(commands);
+  const extensionCommandContracts = resolveExtensionCommandContracts(selection, runtime, outputCommands);
+  const result = createContractsResult(selection, schemaContext, actionContext, outputCommands);
+  if (!(selection.flagsOnly && !selection.fullOutput)) {
+    attachRuntimeContractsResult(result, runtime);
+  }
+  attachSchemaContractsResult(result, selection, schemaContext, extensionCommandContracts);
+  attachFlagContractsResult(result, selection, runtime, outputCommands, commandAliases);
+  attachCommanderAliasContractsResult(result, selection);
+  if (selection.fullOutput && !selection.schemaOnly && !selection.flagsOnly && !selection.availabilityOnly) {
+    result.mcp_tools = buildMcpToolContracts();
+  }
+  return result;
+}
+var _testOnlyContractsCommand = {
+  actionDescriptorMatchesSelectedCommand,
+  attachCreateRequiredOptionContracts,
+  buildExtensionActionSchemaBranch,
+  buildRuntimeFieldFlagContracts,
+  collectActionContractDescriptors,
+  collectExtensionCommandContracts,
+  collectExtensionFlagContractsByCommand,
+  extractActionBranches,
+  extensionSchemaPropertyNameFromFlag,
+  filterSchemaByAction,
+  filterSchemaByActions,
+  isCoreCommandPath,
+  mergeExtensionContractsByAction,
+  normalizeActionNameFromCommand,
+  normalizeCommandForRuntimeFieldFlags,
+  normalizeCommandPath,
+  packageOwnedActionForCommand,
+  resolveActionCommandPath,
+  resolveActionAvailability,
+  resolveCoreCommandFlags,
+  resolveScopedCommandsFromActionDescriptors,
+  splitCommandPathAliases,
+  toRuntimeLongFlagToken,
+  toRuntimeShortFlagToken
+};
+
+export {
+  runContracts,
+  _testOnlyContractsCommand
+};
+//# sourceMappingURL=chunk-5GZ7TDD6.js.map