@unbrained/pm-cli 2026.7.6 → 2026.7.8

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

@@ -1,1868 +0,0 @@
-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