@unbrained/pm-cli 2026.5.31 → 2026.6.6

package/dist/cli-bundle/chunks/contracts-QDB6OMLQ.js

@@ -0,0 +1,1278 @@
+
+!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]="2bf10312-dfcc-5f58-aca8-f410e10f7126")}catch(e){}}();
+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,
+  DELETE_FLAG_CONTRACTS,
+  DEPS_FLAG_CONTRACTS,
+  DOCS_FLAG_CONTRACTS,
+  EXTENSION_ACTIVATE_FLAG_CONTRACTS,
+  EXTENSION_ADOPT_ALL_FLAG_CONTRACTS,
+  EXTENSION_ADOPT_FLAG_CONTRACTS,
+  EXTENSION_CATALOG_FLAG_CONTRACTS,
+  EXTENSION_DEACTIVATE_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_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,
+  NORMALIZE_FLAG_CONTRACTS,
+  NOTES_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,
+  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-KWU6HG75.js";
+import {
+  commandOptionFlagLabel,
+  resolveCommandOptionPolicyState,
+  resolveItemTypeRegistry
+} from "./chunk-2VBQ6ZXS.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  SETTINGS_DEFAULTS,
+  activateExtensions,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  loadExtensions,
+  pathExists,
+  readSettings,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry
+} from "./chunk-5SFCOO6B.js";
+
+// dist/cli/commands/contracts.js
+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",
+  "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",
+  "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"],
+  ["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"],
+  ["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 EXTENSION_PACKAGE_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],
+  ["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 CORE_COMMAND_FLAG_CONTRACT_ENTRIES = [
+  ...EXTENSION_PACKAGE_LIFECYCLE_FLAG_CONTRACTS.flatMap(([subcommand, flags]) => [
+    [`extension ${subcommand}`, flags],
+    [`package ${subcommand}`, flags],
+    [`packages ${subcommand}`, flags]
+  ]),
+  ["init", INIT_FLAG_CONTRACTS],
+  ["config", CONFIG_FLAG_CONTRACTS],
+  ["extension", EXTENSION_FLAG_CONTRACTS],
+  ["package", EXTENSION_FLAG_CONTRACTS],
+  ["packages", EXTENSION_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],
+  ["aggregate", AGGREGATE_FLAG_CONTRACTS],
+  ["dedupe-audit", DEDUPE_AUDIT_FLAG_CONTRACTS],
+  ["deps", DEPS_FLAG_CONTRACTS],
+  ["guide", GUIDE_FLAG_CONTRACTS],
+  ["reindex", REINDEX_FLAG_CONTRACTS],
+  ["history", HISTORY_FLAG_CONTRACTS],
+  ["history-redact", HISTORY_REDACT_FLAG_CONTRACTS],
+  ["history-repair", HISTORY_REPAIR_FLAG_CONTRACTS],
+  ["schema", SCHEMA_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 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;
+  }
+  const description = toOptionalTrimmedString(definition.description);
+  if (description) {
+    contract.description = description;
+  }
+  if (definition.required === true) {
+    contract.required = true;
+  }
+  if (definition.repeatable === true) {
+    contract.repeatable = true;
+  }
+  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 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) {
+    if (argument.variadic) {
+      properties[argument.name] = {
+        type: "array",
+        items: { type: "string" },
+        description: argument.description ?? `Variadic argument '${argument.name}' for extension action '${contract.action}'.`
+      };
+    } else {
+      properties[argument.name] = {
+        type: "string",
+        description: argument.description ?? `Argument '${argument.name}' for extension action '${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;
+    }
+    const valueType = flag.value_type ?? "boolean";
+    const schemaType = valueType === "boolean" ? "boolean" : valueType === "number" ? ["number", "string"] : "string";
+    properties[propertyName] = {
+      type: flag.repeatable ? "array" : schemaType,
+      ...flag.repeatable ? { items: { type: schemaType } } : {},
+      description: flag.description ?? `Extension option '${flag.flag}' for action '${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(global) {
+  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 (global.noExtensions) {
+    return {
+      handlers: /* @__PURE__ */ new Set(),
+      disabledReason: "extensions_disabled",
+      commandDefinitions: [],
+      flagRegistrations: [],
+      registrations: null,
+      policyState: defaultPolicyState
+    };
+  }
+  const pmRoot = resolvePmRoot(process.cwd(), global.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
+  };
+}
+async function runContracts(options, global) {
+  const selectedAction = normalizeToken(options.action);
+  const selectedCommand = normalizeToken(options.command);
+  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 unfilteredDefaultBriefMode = !fullOutput && !schemaOnly && !flagsOnly && !availabilityOnly && !selectedAction && !selectedCommand;
+  const omitUnfilteredSchema = unfilteredDefaultBriefMode;
+  const omitUnfilteredCommandFlags = unfilteredDefaultBriefMode;
+  const omitUnfilteredCommanderAliases = unfilteredDefaultBriefMode;
+  const projectionFlagsEnabled = [
+    schemaOnly,
+    flagsOnly,
+    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);
+  }
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  let settings = structuredClone(SETTINGS_DEFAULTS);
+  try {
+    settings = await readSettings(pmRoot);
+  } catch {
+    settings = structuredClone(SETTINGS_DEFAULTS);
+  }
+  const runtimeProbe = await resolveRuntimeExtensionActionProbe(global);
+  const typeRegistry = resolveItemTypeRegistry(settings, runtimeProbe.registrations ?? getActiveExtensionRegistrations());
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const runtimeFieldFlagMap = buildRuntimeFieldFlagContracts(runtimeFieldRegistry);
+  const createRequiredOptionContracts = buildCreateRequiredOptionContracts(typeRegistry);
+  const extensionContracts = collectExtensionCommandContracts(runtimeProbe);
+  const mergedExtensionContracts = mergeExtensionContractsByAction(extensionContracts);
+  const extensionFlagMap = collectExtensionFlagContractsByCommand(runtimeProbe.flagRegistrations);
+  const includePackageOwnedActions = selectedAction !== void 0 && PACKAGE_OWNED_ACTIONS.has(selectedAction) && availabilityOnly || selectedCommand !== void 0 && PACKAGE_OWNED_COMMANDS.has(selectedCommand) && availabilityOnly;
+  const actionDescriptors = collectActionContractDescriptors(mergedExtensionContracts, { includePackageOwnedActions });
+  if (includePackageOwnedActions && selectedCommand !== void 0 && PACKAGE_OWNED_COMMANDS.has(selectedCommand) && !actionDescriptors.some((entry) => entry.command_path === selectedCommand)) {
+    actionDescriptors.push({
+      action: packageOwnedActionForCommand(selectedCommand),
+      provider: "extension",
+      requires_extension: true,
+      command_path: selectedCommand
+    });
+  }
+  const actionNames = new Set(actionDescriptors.map((entry) => entry.action));
+  if (selectedAction && !actionNames.has(selectedAction)) {
+    throw new PmCliError(`Unknown action: "${options.action}".`, EXIT_CODE.USAGE);
+  }
+  const commandCatalog = [
+    .../* @__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)),
+      ...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));
+  const commandNames = new Set(commandCatalog);
+  if (selectedCommand && !commandNames.has(selectedCommand)) {
+    const packageHint = PACKAGE_OWNED_COMMAND_INSTALL_HINTS.get(selectedCommand);
+    if (packageHint) {
+      throw new PmCliError(`Unknown command: "${options.command}". Command "${selectedCommand}" 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 ${selectedCommand} --flags-only --json`],
+        nextSteps: [`Install the optional package first: pm install ${packageHint} --project`],
+        recovery: {
+          suggested_retry: `pm install ${packageHint} --project`
+        }
+      });
+    }
+    throw new PmCliError(`Unknown command: "${options.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"
+      }
+    });
+  }
+  const selectedPackageOwnedAction = selectedCommand ? PACKAGE_OWNED_COMMAND_ACTIONS.get(selectedCommand) : void 0;
+  const commandScopedDescriptors = selectedCommand ? actionDescriptors.filter((descriptor) => selectedPackageOwnedAction ? descriptor.action === selectedPackageOwnedAction : actionDescriptorMatchesSelectedCommand(descriptor, selectedCommand)) : actionDescriptors;
+  if (selectedCommand && selectedAction && !commandScopedDescriptors.some((descriptor) => descriptor.action === selectedAction)) {
+    throw new PmCliError(`Action "${options.action}" is not mapped to command "${options.command}" in contracts output.`, EXIT_CODE.USAGE);
+  }
+  const schema = PM_TOOL_PARAMETERS_SCHEMA;
+  const schemaBranches = extractActionBranches(schema);
+  const schemaActionSet = new Set(schemaBranches.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));
+  const extensionBranches = mergedExtensionContracts.filter((contract) => !schemaActionSet.has(contract.action)).map((contract) => buildExtensionActionSchemaBranch(contract));
+  const mergedSchema = extensionBranches.length > 0 ? {
+    ...schema,
+    oneOf: [...schemaBranches, ...extensionBranches]
+  } : schema;
+  const scopedActionDescriptors = selectedAction ? commandScopedDescriptors.filter((descriptor) => descriptor.action === selectedAction) : commandScopedDescriptors;
+  const allActionAvailability = [
+    ...new Map(scopedActionDescriptors.map((descriptor) => resolveActionAvailability(descriptor, runtimeProbe)).map((entry) => [
+      selectedPackageOwnedAction ? entry.action : `${entry.action}|${entry.command_path ?? ""}`,
+      entry
+    ])).values()
+  ];
+  const actionAvailability = runtimeOnly && !selectedAction && !availabilityOnly ? allActionAvailability.filter((entry) => entry.invocable) : allActionAvailability;
+  const actions = [...new Set(actionAvailability.map((entry) => entry.action))];
+  const descriptorActionSet = new Set(actionDescriptors.map((descriptor) => descriptor.action));
+  let filteredSchema = selectedAction ? filterSchemaByAction(mergedSchema, selectedAction) : selectedCommand ? filterSchemaByActions(mergedSchema, new Set(scopedActionDescriptors.map((descriptor) => descriptor.action))) : filterSchemaByActions(mergedSchema, descriptorActionSet);
+  if (runtimeOnly && !selectedAction) {
+    filteredSchema = filterSchemaByActions(filteredSchema, new Set(actions));
+  }
+  const includeSchemaSurface = !flagsOnly && !availabilityOnly;
+  if (includeSchemaSurface) {
+    filteredSchema = attachCreateRequiredOptionContracts(filteredSchema, createRequiredOptionContracts);
+  }
+  const commands = selectedCommand !== void 0 ? [selectedCommand] : selectedAction ? resolveScopedCommandsFromActionDescriptors(scopedActionDescriptors, commandCatalog) : commandCatalog;
+  const outputCommands = flagsOnly && selectedCommand === void 0 && selectedAction === void 0 ? compactCommandAliasSurface(commands) : commands;
+  const commandAliases = buildCommandAliasSurface(commands);
+  const extensionCommandContracts = selectedCommand ? extensionContracts.filter((entry) => entry.command === selectedCommand) : selectedAction ? extensionContracts.filter((entry) => outputCommands.includes(normalizeCommandPath(entry.command))) : extensionContracts;
+  const includeRuntimeContractSections = !(flagsOnly && !fullOutput);
+  const result = {
+    schema_version: typeof mergedSchema["x-schema-version"] === "string" ? mergedSchema["x-schema-version"] : null,
+    schema_id: typeof mergedSchema.$id === "string" ? mergedSchema.$id : null,
+    selected: {
+      action: selectedAction ?? null,
+      command: selectedCommand ?? null,
+      schema_only: schemaOnly,
+      flags_only: flagsOnly,
+      availability_only: availabilityOnly,
+      runtime_only: runtimeOnly,
+      command_scoped: selectedCommand !== void 0
+    },
+    commands: outputCommands
+  };
+  if (includeRuntimeContractSections) {
+    result.runtime_schema = {
+      statuses: statusRegistry.definitions.map((definition) => definition.id),
+      open_status: statusRegistry.open_status,
+      close_status: statusRegistry.close_status,
+      canceled_status: statusRegistry.canceled_status,
+      types: [...typeRegistry.types],
+      fields_by_command: Object.fromEntries([...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"
+      }
+    };
+  }
+  if (!flagsOnly) {
+    result.actions = actions;
+    result.action_availability = actionAvailability;
+  }
+  if (includeSchemaSurface && !omitUnfilteredSchema) {
+    result.schema = filteredSchema;
+    result.extension_commands = extensionCommandContracts;
+  } else if (includeSchemaSurface && omitUnfilteredSchema) {
+    result.schema_omitted_reason = "unfiltered_default_brief";
+    result.extension_commands = extensionCommandContracts;
+  }
+  if (!schemaOnly && !availabilityOnly) {
+    if (!omitUnfilteredCommandFlags) {
+      result.command_flags = buildCommandFlagSurface(outputCommands, extensionFlagMap, runtimeFieldFlagMap);
+    } else {
+      result.command_flags_omitted_reason = "unfiltered_default_brief";
+    }
+    if (commandAliases.length > 0) {
+      result.command_aliases = commandAliases;
+    }
+  }
+  if (!schemaOnly && !flagsOnly && !availabilityOnly) {
+    if (!omitUnfilteredCommanderAliases) {
+      result.commander_aliases = buildCommanderAliasSurface();
+    } else {
+      result.commander_aliases_omitted_reason = "unfiltered_default_brief";
+    }
+  }
+  return result;
+}
+export {
+  runContracts
+};
+//# sourceMappingURL=contracts-QDB6OMLQ.js.map
+
+//# debugId=2bf10312-dfcc-5f58-aca8-f410e10f7126