@unbrained/pm-cli 2026.7.6 → 2026.7.8

package/dist/cli-bundle/chunks/chunk-4IWYTWGF.js

@@ -1,819 +0,0 @@
-
-!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]="3b942722-344b-5a0e-9629-7a60719de19e")}catch(e){}}();
-import {
-  refreshSearchArtifactsForMutation,
-  shouldRunSearchRefreshInForeground
-} from "./chunk-EOKXK3R3.js";
-import {
-  printError,
-  writeStdout
-} from "./chunk-MLIYFOE7.js";
-import {
-  ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS,
-  CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS,
-  CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
-  CREATE_COMMANDER_STRING_OPTION_CONTRACTS,
-  LIST_COMMANDER_STRING_OPTION_CONTRACTS,
-  NEXT_COMMANDER_STRING_OPTION_CONTRACTS,
-  SEARCH_COMMANDER_STRING_OPTION_CONTRACTS,
-  UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS,
-  UPDATE_COMMANDER_STRING_OPTION_CONTRACTS,
-  readFirstStringFromCommanderOptions,
-  readFirstValueFromCommanderOptions,
-  readStringArrayFromCommanderOptions
-} from "./chunk-EGAP5OWD.js";
-import {
-  PmCliError,
-  readSettings,
-  setActiveCommandResult
-} from "./chunk-E3SZTQ4K.js";
-import {
-  EXIT_CODE,
-  getSettingsPath,
-  pathExists,
-  resolvePmRoot
-} from "./chunk-57NWPFF2.js";
-
-// dist/cli/registration-helpers.js
-var RESOLVED_GLOBAL_OPTIONS = /* @__PURE__ */ Symbol("pm.resolvedGlobalOptions");
-function commandOptionsReader(command) {
-  return typeof command === "object" && command !== null ? command : {};
-}
-function resolveCommanderContract(contracts, target) {
-  const contract = contracts.find((entry) => entry.target === target);
-  return contract ?? { target, keys: [target] };
-}
-function setResolvedGlobalOptions(command, globalOptions) {
-  command[RESOLVED_GLOBAL_OPTIONS] = { ...globalOptions };
-}
-function clearResolvedGlobalOptions(command) {
-  delete command[RESOLVED_GLOBAL_OPTIONS];
-}
-function getGlobalOptions(command) {
-  const resolved = command[RESOLVED_GLOBAL_OPTIONS];
-  if (resolved) {
-    return { ...resolved };
-  }
-  const reader = commandOptionsReader(command);
-  const opts = typeof reader.optsWithGlobals === "function" ? reader.optsWithGlobals() : typeof reader.opts === "function" ? reader.opts() : {};
-  return {
-    json: opts.json === true ? true : void 0,
-    quiet: Boolean(opts.quiet),
-    noChangedFields: opts.changedFields === false,
-    idOnly: opts.idOnly === true,
-    path: typeof opts.pmPath === "string" ? opts.pmPath : typeof opts.path === "string" ? opts.path : void 0,
-    noExtensions: opts.extensions === false,
-    noPager: Boolean(opts.noPager),
-    profile: Boolean(opts.profile)
-  };
-}
-function getCommandPath(command) {
-  const parts = [];
-  let current = command;
-  while (current?.parent) {
-    parts.unshift(current.name());
-    current = current.parent;
-  }
-  return parts.join(" ");
-}
-async function applyDefaultOutputFormat(globalOptions) {
-  if (globalOptions.json === true) {
-    return globalOptions;
-  }
-  const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    return globalOptions;
-  }
-  const settings = await readSettings(pmRoot);
-  return {
-    ...globalOptions,
-    defaultOutputFormat: settings.output.default_format
-  };
-}
-function collect(value, previous) {
-  const next = previous ?? [];
-  next.push(value);
-  return next;
-}
-function pushOptionalValueFlag(args, flag, value) {
-  if (typeof value !== "string") {
-    return;
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    return;
-  }
-  args.push(flag, trimmed);
-}
-function pushOptionalBooleanFlag(args, flag, value) {
-  if (value === true) {
-    args.push(flag);
-  }
-}
-function pushRepeatableValueFlag(args, flag, values) {
-  if (!Array.isArray(values)) {
-    return;
-  }
-  for (const value of values) {
-    if (typeof value !== "string") {
-      continue;
-    }
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    args.push(flag, trimmed);
-  }
-}
-function optionTrue(options, key) {
-  return options[key] === true ? true : void 0;
-}
-function optionFalse(options, key) {
-  return options[key] === false ? true : void 0;
-}
-function readOptionString(options, key) {
-  return typeof options[key] === "string" ? options[key] : void 0;
-}
-function anyOptionTrue(options, keys) {
-  return keys.some((key) => options[key] === true) ? true : void 0;
-}
-function copyUnknownOptions(target, source) {
-  for (const [key, value] of Object.entries(source)) {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") {
-      continue;
-    }
-    if (Object.hasOwn(target, key)) {
-      continue;
-    }
-    target[key] = value;
-  }
-}
-function buildBackgroundTestCommandArgs(id, options) {
-  const args = ["test", id, "--run", "--json", "--progress"];
-  pushRepeatableValueFlag(args, "--add", options.add);
-  pushRepeatableValueFlag(args, "--add-json", options.addJson);
-  pushRepeatableValueFlag(args, "--remove", options.remove);
-  pushOptionalValueFlag(args, "--match", options.match);
-  pushOptionalValueFlag(args, "--only-index", options.onlyIndex);
-  pushOptionalBooleanFlag(args, "--only-last", options.onlyLast);
-  pushOptionalValueFlag(args, "--timeout", options.timeout);
-  pushRepeatableValueFlag(args, "--env-set", options.envSet);
-  pushRepeatableValueFlag(args, "--env-clear", options.envClear);
-  pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
-  pushOptionalValueFlag(args, "--pm-context", options.pmContext);
-  pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
-  pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
-  pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
-  pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
-  pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
-  pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
-  pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
-  pushOptionalValueFlag(args, "--author", options.author);
-  pushOptionalValueFlag(args, "--message", options.message);
-  pushOptionalBooleanFlag(args, "--force", options.force);
-  return args;
-}
-function buildBackgroundTestAllCommandArgs(options) {
-  const args = ["test-all", "--json", "--progress"];
-  pushOptionalValueFlag(args, "--status", options.status);
-  pushOptionalValueFlag(args, "--limit", options.limit);
-  pushOptionalValueFlag(args, "--offset", options.offset);
-  pushOptionalValueFlag(args, "--timeout", options.timeout);
-  pushRepeatableValueFlag(args, "--env-set", options.envSet);
-  pushRepeatableValueFlag(args, "--env-clear", options.envClear);
-  pushOptionalBooleanFlag(args, "--shared-host-safe", options.sharedHostSafe);
-  pushOptionalValueFlag(args, "--pm-context", options.pmContext);
-  pushOptionalBooleanFlag(args, "--override-linked-pm-context", options.overrideLinkedPmContext);
-  pushOptionalBooleanFlag(args, "--fail-on-context-mismatch", options.failOnContextMismatch);
-  pushOptionalBooleanFlag(args, "--fail-on-skipped", options.failOnSkipped);
-  pushOptionalBooleanFlag(args, "--fail-on-empty-test-run", options.failOnEmptyTestRun);
-  pushOptionalBooleanFlag(args, "--require-assertions-for-pm", options.requireAssertionsForPm);
-  pushOptionalBooleanFlag(args, "--check-context", options.checkContext);
-  pushOptionalBooleanFlag(args, "--auto-pm-context", options.autoPmContext);
-  return args;
-}
-function formatHookWarnings(warnings) {
-  return warnings.join(",");
-}
-function normalizeCreateOptions(commandOptions, options = {}) {
-  const readCreateString = (target) => readFirstStringFromCommanderOptions(commandOptions, resolveCommanderContract(CREATE_COMMANDER_STRING_OPTION_CONTRACTS, target));
-  const readCreateList = (target) => readStringArrayFromCommanderOptions(commandOptions, resolveCommanderContract(CREATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, target));
-  const type = readCreateString("type");
-  if (options.requireType !== false && type === void 0) {
-    throw new PmCliError("Missing required option --type <value>. Why required: create resolves runtime schema fields/workflow from item type. Retry: add --type <built-in or configured custom type> (example: --type Task).", EXIT_CODE.USAGE);
-  }
-  const normalized = {
-    title: readCreateString("title"),
-    description: readCreateString("description"),
-    type,
-    template: readCreateString("template"),
-    createMode: readCreateString("createMode"),
-    schedulePreset: readCreateString("schedulePreset"),
-    status: readCreateString("status"),
-    priority: readCreateString("priority"),
-    tags: readCreateString("tags"),
-    addTags: readCreateList("addTags"),
-    body: readCreateString("body"),
-    deadline: readCreateString("deadline"),
-    estimatedMinutes: readCreateString("estimatedMinutes"),
-    acceptanceCriteria: readCreateString("acceptanceCriteria"),
-    definitionOfReady: readCreateString("definitionOfReady"),
-    order: readCreateString("order"),
-    rank: readCreateString("rank"),
-    goal: readCreateString("goal"),
-    objective: readCreateString("objective"),
-    value: readCreateString("value"),
-    impact: readCreateString("impact"),
-    outcome: readCreateString("outcome"),
-    whyNow: readCreateString("whyNow"),
-    author: readCreateString("author"),
-    message: readCreateString("message"),
-    assignee: readCreateString("assignee"),
-    parent: readCreateString("parent"),
-    allowMissingParent: optionTrue(commandOptions, "allowMissingParent") === true,
-    reviewer: readCreateString("reviewer"),
-    risk: readCreateString("risk"),
-    confidence: readCreateString("confidence"),
-    sprint: readCreateString("sprint"),
-    release: readCreateString("release"),
-    blockedBy: readCreateString("blockedBy"),
-    blockedReason: readCreateString("blockedReason"),
-    unblockNote: readCreateString("unblockNote"),
-    reporter: readCreateString("reporter"),
-    severity: readCreateString("severity"),
-    environment: readCreateString("environment"),
-    reproSteps: readCreateString("reproSteps"),
-    resolution: readCreateString("resolution"),
-    expectedResult: readCreateString("expectedResult"),
-    actualResult: readCreateString("actualResult"),
-    affectedVersion: readCreateString("affectedVersion"),
-    fixedVersion: readCreateString("fixedVersion"),
-    component: readCreateString("component"),
-    regression: readCreateString("regression"),
-    customerImpact: readCreateString("customerImpact"),
-    dep: readCreateList("dep"),
-    comment: readCreateList("comment"),
-    note: readCreateList("note"),
-    learning: readCreateList("learning"),
-    file: readCreateList("file"),
-    test: readCreateList("test"),
-    doc: readCreateList("doc"),
-    reminder: readCreateList("reminder"),
-    event: readCreateList("event"),
-    typeOption: readCreateList("typeOption"),
-    field: readCreateList("field"),
-    unset: readCreateList("unset"),
-    clearDeps: optionTrue(commandOptions, "clearDeps"),
-    clearComments: optionTrue(commandOptions, "clearComments"),
-    clearNotes: optionTrue(commandOptions, "clearNotes"),
-    clearLearnings: optionTrue(commandOptions, "clearLearnings"),
-    clearFiles: optionTrue(commandOptions, "clearFiles"),
-    clearTests: optionTrue(commandOptions, "clearTests"),
-    clearDocs: optionTrue(commandOptions, "clearDocs"),
-    clearReminders: optionTrue(commandOptions, "clearReminders"),
-    clearEvents: optionTrue(commandOptions, "clearEvents"),
-    clearTypeOptions: optionTrue(commandOptions, "clearTypeOptions")
-  };
-  copyUnknownOptions(normalized, commandOptions);
-  return normalized;
-}
-function normalizeUpdateOptions(commandOptions) {
-  const readUpdateString = (target) => readFirstStringFromCommanderOptions(commandOptions, resolveCommanderContract(UPDATE_COMMANDER_STRING_OPTION_CONTRACTS, target));
-  const readUpdateList = (target) => readStringArrayFromCommanderOptions(commandOptions, resolveCommanderContract(UPDATE_COMMANDER_REPEATABLE_OPTION_CONTRACTS, target));
-  const normalized = {
-    title: readUpdateString("title"),
-    description: readUpdateString("description"),
-    body: readUpdateString("body"),
-    status: readUpdateString("status"),
-    closeReason: readUpdateString("closeReason"),
-    priority: readUpdateString("priority"),
-    type: readUpdateString("type"),
-    tags: readUpdateString("tags"),
-    addTags: readUpdateList("addTags"),
-    removeTags: readUpdateList("removeTags"),
-    deadline: readUpdateString("deadline"),
-    estimatedMinutes: readUpdateString("estimatedMinutes"),
-    acceptanceCriteria: readUpdateString("acceptanceCriteria"),
-    definitionOfReady: readUpdateString("definitionOfReady"),
-    order: readUpdateString("order"),
-    rank: readUpdateString("rank"),
-    goal: readUpdateString("goal"),
-    objective: readUpdateString("objective"),
-    value: readUpdateString("value"),
-    impact: readUpdateString("impact"),
-    outcome: readUpdateString("outcome"),
-    whyNow: readUpdateString("whyNow"),
-    author: readUpdateString("author"),
-    message: readUpdateString("message"),
-    force: Boolean(commandOptions.force),
-    allowAuditUpdate: anyOptionTrue(commandOptions, ["allowAuditUpdate", "allow_audit_update"]),
-    allowAuditDepUpdate: anyOptionTrue(commandOptions, ["allowAuditDepUpdate", "allow_audit_dep_update"]),
-    assignee: readUpdateString("assignee"),
-    parent: readUpdateString("parent"),
-    reviewer: readUpdateString("reviewer"),
-    risk: readUpdateString("risk"),
-    confidence: readUpdateString("confidence"),
-    sprint: readUpdateString("sprint"),
-    release: readUpdateString("release"),
-    blockedBy: readUpdateString("blockedBy"),
-    blockedReason: readUpdateString("blockedReason"),
-    unblockNote: readUpdateString("unblockNote"),
-    reporter: readUpdateString("reporter"),
-    severity: readUpdateString("severity"),
-    environment: readUpdateString("environment"),
-    reproSteps: readUpdateString("reproSteps"),
-    resolution: readUpdateString("resolution"),
-    expectedResult: readUpdateString("expectedResult"),
-    actualResult: readUpdateString("actualResult"),
-    affectedVersion: readUpdateString("affectedVersion"),
-    fixedVersion: readUpdateString("fixedVersion"),
-    component: readUpdateString("component"),
-    regression: readUpdateString("regression"),
-    customerImpact: readUpdateString("customerImpact"),
-    dep: readUpdateList("dep"),
-    depRemove: readUpdateList("depRemove"),
-    replaceDeps: optionTrue(commandOptions, "replaceDeps"),
-    replaceTests: optionTrue(commandOptions, "replaceTests"),
-    comment: readUpdateList("comment"),
-    note: readUpdateList("note"),
-    learning: readUpdateList("learning"),
-    file: readUpdateList("file"),
-    test: readUpdateList("test"),
-    doc: readUpdateList("doc"),
-    reminder: readUpdateList("reminder"),
-    event: readUpdateList("event"),
-    typeOption: readUpdateList("typeOption"),
-    field: readUpdateList("field"),
-    unset: readUpdateList("unset"),
-    clearDeps: optionTrue(commandOptions, "clearDeps"),
-    clearComments: optionTrue(commandOptions, "clearComments"),
-    clearNotes: optionTrue(commandOptions, "clearNotes"),
-    clearLearnings: optionTrue(commandOptions, "clearLearnings"),
-    clearFiles: optionTrue(commandOptions, "clearFiles"),
-    clearTests: optionTrue(commandOptions, "clearTests"),
-    clearDocs: optionTrue(commandOptions, "clearDocs"),
-    clearReminders: optionTrue(commandOptions, "clearReminders"),
-    clearEvents: optionTrue(commandOptions, "clearEvents"),
-    clearTypeOptions: optionTrue(commandOptions, "clearTypeOptions")
-  };
-  copyUnknownOptions(normalized, commandOptions);
-  return normalized;
-}
-var UPDATE_MANY_CONTROL_OPTION_KEYS = /* @__PURE__ */ new Set([
-  "filterStatus",
-  "filterType",
-  "filterTag",
-  "filterPriority",
-  "filterDeadlineBefore",
-  "filterDeadlineAfter",
-  "filterUpdatedAfter",
-  "filterUpdatedBefore",
-  "filterCreatedAfter",
-  "filterCreatedBefore",
-  "filterAssignee",
-  "filterAssigneeFilter",
-  "filterAssignee_filter",
-  "filterParent",
-  "filterSprint",
-  "filterRelease",
-  "filterAcMissing",
-  "filterEstimatesMissing",
-  "filterEstimateMissing",
-  "filterResolutionMissing",
-  "filterMetadataMissing",
-  "filterReviewerMissing",
-  "filterRiskMissing",
-  "filterConfidenceMissing",
-  "filterSprintMissing",
-  "filterReleaseMissing",
-  "filterHasNotes",
-  "filterNoNotes",
-  "filterHasLearnings",
-  "filterNoLearnings",
-  "filterHasFiles",
-  "filterNoFiles",
-  "filterHasDocs",
-  "filterNoDocs",
-  "filterHasTests",
-  "filterNoTests",
-  "filterHasComments",
-  "filterNoComments",
-  "filterHasDeps",
-  "filterNoDeps",
-  "filterHasBody",
-  "filterEmptyBody",
-  "filterHasLinkedCommand",
-  "filterNoLinkedCommand",
-  "ids",
-  "limit",
-  "offset",
-  "dryRun",
-  "rollback",
-  "checkpoint"
-]);
-function extractUpdateManyMutationOptionSource(commandOptions) {
-  const mutationOptions = {};
-  for (const [key, value] of Object.entries(commandOptions)) {
-    if (UPDATE_MANY_CONTROL_OPTION_KEYS.has(key)) {
-      continue;
-    }
-    mutationOptions[key] = value;
-  }
-  return mutationOptions;
-}
-function readListOptionString(options, target) {
-  const contract = resolveCommanderContract(LIST_COMMANDER_STRING_OPTION_CONTRACTS, target);
-  const stringValue = readFirstStringFromCommanderOptions(options, contract);
-  if (stringValue !== void 0) {
-    return stringValue;
-  }
-  for (const key of contract.keys) {
-    const value = options[key];
-    if (target === "ids" && typeof value === "string") {
-      return value;
-    }
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return String(value);
-    }
-  }
-  return void 0;
-}
-function readSelectionFilterOptionFields(options) {
-  const filterFilesMissing = optionTrue(options, "filterFilesMissing");
-  const filterDocsMissing = optionTrue(options, "filterDocsMissing");
-  return {
-    filterReviewerMissing: optionTrue(options, "filterReviewerMissing"),
-    filterRiskMissing: optionTrue(options, "filterRiskMissing"),
-    filterConfidenceMissing: optionTrue(options, "filterConfidenceMissing"),
-    filterSprintMissing: optionTrue(options, "filterSprintMissing"),
-    filterReleaseMissing: optionTrue(options, "filterReleaseMissing"),
-    hasNotes: optionTrue(options, "hasNotes"),
-    hasLearnings: optionTrue(options, "hasLearnings"),
-    hasFiles: optionTrue(options, "hasFiles"),
-    hasDocs: optionTrue(options, "hasDocs"),
-    hasTests: optionTrue(options, "hasTests"),
-    hasComments: optionTrue(options, "hasComments"),
-    hasDeps: optionTrue(options, "hasDeps"),
-    hasBody: optionTrue(options, "hasBody"),
-    hasLinkedCommand: optionTrue(options, "hasLinkedCommand"),
-    noNotes: optionFalse(options, "notes"),
-    noLearnings: optionFalse(options, "learnings"),
-    noFiles: optionFalse(options, "files") ?? filterFilesMissing,
-    filterFilesMissing,
-    noDocs: optionFalse(options, "docs") ?? filterDocsMissing,
-    filterDocsMissing,
-    noTests: optionFalse(options, "tests"),
-    noComments: optionFalse(options, "comments"),
-    noDeps: optionFalse(options, "deps"),
-    emptyBody: optionTrue(options, "emptyBody"),
-    noLinkedCommand: optionFalse(options, "linkedCommand")
-  };
-}
-function normalizeListOptions(options) {
-  const normalized = {
-    status: readListOptionString(options, "status"),
-    type: readListOptionString(options, "type"),
-    tag: readListOptionString(options, "tag"),
-    priority: readListOptionString(options, "priority"),
-    deadlineBefore: readListOptionString(options, "deadlineBefore"),
-    deadlineAfter: readListOptionString(options, "deadlineAfter"),
-    updatedAfter: readListOptionString(options, "updatedAfter"),
-    updatedBefore: readListOptionString(options, "updatedBefore"),
-    createdAfter: readListOptionString(options, "createdAfter"),
-    createdBefore: readListOptionString(options, "createdBefore"),
-    ids: readListOptionString(options, "ids"),
-    assignee: readListOptionString(options, "assignee"),
-    assigneeFilter: readListOptionString(options, "assigneeFilter"),
-    parent: readListOptionString(options, "parent"),
-    sprint: readListOptionString(options, "sprint"),
-    release: readListOptionString(options, "release"),
-    limit: readListOptionString(options, "limit"),
-    offset: readListOptionString(options, "offset"),
-    // Commander stores --no-truncate as truncate=false; --all is the positive alias.
-    noTruncate: optionFalse(options, "truncate") ?? optionTrue(options, "all"),
-    includeBody: optionTrue(options, "includeBody"),
-    compact: optionTrue(options, "compact"),
-    brief: optionTrue(options, "brief"),
-    full: optionTrue(options, "full"),
-    fields: readListOptionString(options, "fields"),
-    sort: readListOptionString(options, "sort"),
-    order: readListOptionString(options, "order"),
-    tree: optionTrue(options, "tree"),
-    treeDepth: readListOptionString(options, "treeDepth"),
-    filterAcMissing: optionTrue(options, "filterAcMissing"),
-    filterEstimatesMissing: anyOptionTrue(options, ["filterEstimatesMissing", "filterEstimateMissing"]),
-    filterResolutionMissing: optionTrue(options, "filterResolutionMissing"),
-    filterMetadataMissing: optionTrue(options, "filterMetadataMissing"),
-    // Governance-missing (GH-236) + content presence/absence (GH-242) filters.
-    ...readSelectionFilterOptionFields(options)
-  };
-  copyUnknownOptions(normalized, options);
-  return normalized;
-}
-function normalizeAggregateOptions(options) {
-  return {
-    groupBy: typeof options.groupBy === "string" ? options.groupBy : void 0,
-    count: options.count === true ? true : void 0,
-    completion: options.completion === true ? true : void 0,
-    sum: typeof options.sum === "string" ? options.sum : void 0,
-    avg: typeof options.avg === "string" ? options.avg : void 0,
-    includeUnparented: options.includeUnparented === true || options.include_unparented === true,
-    status: typeof options.status === "string" ? options.status : void 0,
-    type: readListOptionString(options, "type"),
-    tag: readListOptionString(options, "tag"),
-    priority: readListOptionString(options, "priority"),
-    deadlineBefore: readListOptionString(options, "deadlineBefore"),
-    deadlineAfter: readListOptionString(options, "deadlineAfter"),
-    assignee: readListOptionString(options, "assignee"),
-    assigneeFilter: readListOptionString(options, "assigneeFilter"),
-    parent: readListOptionString(options, "parent"),
-    sprint: readListOptionString(options, "sprint"),
-    release: readListOptionString(options, "release")
-  };
-}
-function printListJsonStream(commandName, result, globalOptions) {
-  setActiveCommandResult(result);
-  if (globalOptions.quiet) {
-    return;
-  }
-  const warnings = Array.isArray(result.warnings) ? result.warnings : [];
-  const metaPayload = {
-    type: "meta",
-    command: commandName,
-    count: result.count,
-    now: result.now,
-    filters: result.filters
-  };
-  if (warnings.length > 0) {
-    metaPayload.warnings = warnings;
-  }
-  if (!writeStdout(`${JSON.stringify(metaPayload)}
-`)) {
-    return;
-  }
-  for (const item of result.items) {
-    if (!writeStdout(`${JSON.stringify({ type: "item", command: commandName, item })}
-`)) {
-      return;
-    }
-  }
-  writeStdout(`${JSON.stringify({ type: "end", command: commandName, count: result.count })}
-`);
-}
-function printActivityJsonStream(result, options, globalOptions) {
-  setActiveCommandResult(result);
-  if (globalOptions.quiet) {
-    return;
-  }
-  const metaPayload = {
-    type: "meta",
-    command: "activity",
-    count: result.count,
-    filters: {
-      id: options.id ?? null,
-      op: options.op ?? null,
-      author: options.author ?? null,
-      from: options.from ?? null,
-      to: options.to ?? null,
-      limit: options.limit ?? null
-    }
-  };
-  if (!writeStdout(`${JSON.stringify(metaPayload)}
-`)) {
-    return;
-  }
-  const entries = result.compact && result.compact_activity ? result.compact_activity : result.activity;
-  for (const entry of entries) {
-    if (!writeStdout(`${JSON.stringify({ type: "entry", command: "activity", entry })}
-`)) {
-      return;
-    }
-  }
-  writeStdout(`${JSON.stringify({ type: "end", command: "activity", count: result.count })}
-`);
-}
-function normalizeSearchOptions(options) {
-  const readSearchString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(SEARCH_COMMANDER_STRING_OPTION_CONTRACTS, target));
-  const readSearchStringOrNumber = (target) => {
-    const candidate = readFirstValueFromCommanderOptions(options, resolveCommanderContract(SEARCH_COMMANDER_STRING_OPTION_CONTRACTS, target));
-    if (typeof candidate === "string") {
-      return candidate;
-    }
-    if (typeof candidate === "number" && Number.isFinite(candidate)) {
-      return candidate;
-    }
-    return void 0;
-  };
-  const fields = readSearchString("fields");
-  const compactRequested = options.compact === true;
-  const fullRequested = options.full === true;
-  const defaultCompact = !compactRequested && !fullRequested && fields === void 0;
-  const mode = options.semantic === true ? "semantic" : options.hybrid === true ? "hybrid" : readSearchString("mode");
-  const normalized = {
-    mode,
-    matchMode: readSearchString("matchMode"),
-    minScore: readSearchStringOrNumber("minScore"),
-    count: optionTrue(options, "count"),
-    semanticWeight: readSearchStringOrNumber("semanticWeight"),
-    includeLinked: optionTrue(options, "includeLinked"),
-    titleExact: optionTrue(options, "titleExact"),
-    phraseExact: optionTrue(options, "phraseExact"),
-    highlight: optionTrue(options, "highlight"),
-    status: readSearchString("status"),
-    type: readSearchString("type"),
-    tag: readSearchString("tag"),
-    priority: readSearchString("priority"),
-    deadlineBefore: readSearchString("deadlineBefore"),
-    deadlineAfter: readSearchString("deadlineAfter"),
-    updatedAfter: readSearchString("updatedAfter"),
-    updatedBefore: readSearchString("updatedBefore"),
-    createdAfter: readSearchString("createdAfter"),
-    createdBefore: readSearchString("createdBefore"),
-    assignee: readSearchString("assignee"),
-    sprint: readSearchString("sprint"),
-    release: readSearchString("release"),
-    parent: readSearchString("parent"),
-    limit: readSearchString("limit"),
-    fields,
-    compact: compactRequested || defaultCompact ? true : void 0,
-    full: optionTrue(options, "full"),
-    // Governance-missing (GH-236) + content presence/absence (GH-242) filters,
-    // mirroring normalizeListOptions via the shared field slice.
-    ...readSelectionFilterOptionFields(options)
-  };
-  copyUnknownOptions(normalized, options);
-  return normalized;
-}
-function normalizeSearchKeywordsInput(keywords) {
-  const query = keywords.map((entry) => entry.trim()).filter((entry) => entry.length > 0).join(" ");
-  if (query.length === 0) {
-    throw new PmCliError("Search query must not be empty", EXIT_CODE.USAGE);
-  }
-  return query;
-}
-function normalizeActivityOptions(options) {
-  const readActivityString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(ACTIVITY_COMMANDER_STRING_OPTION_CONTRACTS, target));
-  return {
-    id: readActivityString("id"),
-    op: readActivityString("op"),
-    author: readActivityString("author"),
-    from: readActivityString("from"),
-    to: readActivityString("to"),
-    limit: readActivityString("limit"),
-    compact: options.full === true ? false : options.compact === false ? false : true
-  };
-}
-var ACTIVITY_STREAM_ENABLED_VALUES = /* @__PURE__ */ new Set(["", "rows", "ndjson", "jsonl", "true", "1", "yes", "on"]);
-var ACTIVITY_STREAM_DISABLED_VALUES = /* @__PURE__ */ new Set(["false", "off", "none", "0"]);
-function resolveActivityStreamMode(raw) {
-  if (raw === true) {
-    return true;
-  }
-  if (raw === false || raw === void 0 || raw === null) {
-    return false;
-  }
-  if (typeof raw === "string") {
-    const normalized = raw.trim().toLowerCase();
-    if (ACTIVITY_STREAM_ENABLED_VALUES.has(normalized)) {
-      return true;
-    }
-    if (ACTIVITY_STREAM_DISABLED_VALUES.has(normalized)) {
-      return false;
-    }
-  }
-  throw new PmCliError("Activity --stream accepts rows|ndjson|jsonl (or no value)", EXIT_CODE.USAGE);
-}
-function normalizeContextOptions(options) {
-  const readContextString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(CONTEXT_COMMANDER_STRING_OPTION_CONTRACTS, target));
-  const sectionRaw = options.section;
-  const section = Array.isArray(sectionRaw) ? sectionRaw.filter((v) => typeof v === "string" && v.trim().length > 0) : typeof sectionRaw === "string" && sectionRaw.trim().length > 0 ? [sectionRaw] : void 0;
-  const normalized = {
-    date: readContextString("date"),
-    from: readContextString("from"),
-    to: readContextString("to"),
-    past: options.past === true ? true : void 0,
-    type: readContextString("type"),
-    tag: readContextString("tag"),
-    priority: readContextString("priority"),
-    assignee: readContextString("assignee"),
-    assigneeFilter: readContextString("assigneeFilter"),
-    sprint: readContextString("sprint"),
-    release: readContextString("release"),
-    parent: readContextString("parent"),
-    limit: readContextString("limit"),
-    format: readContextString("format"),
-    depth: readContextString("depth"),
-    fields: readContextString("fields"),
-    section: section && section.length > 0 ? section : void 0,
-    activityLimit: readContextString("activityLimit"),
-    staleThreshold: readContextString("staleThreshold")
-  };
-  for (const [key, value] of Object.entries(options)) {
-    if (Object.hasOwn(normalized, key)) {
-      continue;
-    }
-    normalized[key] = value;
-  }
-  return normalized;
-}
-function normalizeNextOptions(options) {
-  const readNextString = (target) => readFirstStringFromCommanderOptions(options, resolveCommanderContract(NEXT_COMMANDER_STRING_OPTION_CONTRACTS, target));
-  const normalized = {
-    type: readNextString("type"),
-    tag: readNextString("tag"),
-    priority: readNextString("priority"),
-    assignee: readNextString("assignee"),
-    assigneeFilter: readNextString("assigneeFilter"),
-    sprint: readNextString("sprint"),
-    release: readNextString("release"),
-    parent: readNextString("parent"),
-    limit: readNextString("limit"),
-    blockedLimit: readNextString("blockedLimit"),
-    readyOnly: options.readyOnly === true || options.ready_only === true ? true : void 0,
-    format: readNextString("format")
-  };
-  for (const [key, value] of Object.entries(options)) {
-    if (Object.hasOwn(normalized, key)) {
-      continue;
-    }
-    normalized[key] = value;
-  }
-  return normalized;
-}
-function collectMutationItemIds(result) {
-  if (!result || typeof result !== "object") {
-    return [];
-  }
-  const record = result;
-  const ids = /* @__PURE__ */ new Set();
-  const pushId = (value) => {
-    if (typeof value !== "string") {
-      return;
-    }
-    const normalized = value.trim();
-    if (normalized.length === 0) {
-      return;
-    }
-    ids.add(normalized);
-  };
-  pushId(record.id);
-  const item = record.item;
-  if (item && typeof item === "object") {
-    pushId(item.id);
-  }
-  const explicitIds = record.ids;
-  if (Array.isArray(explicitIds)) {
-    for (const candidate of explicitIds) {
-      pushId(candidate);
-    }
-  }
-  const items = record.items;
-  if (Array.isArray(items)) {
-    for (const candidate of items) {
-      if (!candidate || typeof candidate !== "object") {
-        continue;
-      }
-      pushId(candidate.id);
-    }
-  }
-  return [...ids].sort((left, right) => left.localeCompare(right));
-}
-async function invalidateSearchCachesForMutation(globalOptions, result) {
-  const pmRoot = resolvePmRoot(process.cwd(), globalOptions.path);
-  const refreshResult = await refreshSearchArtifactsForMutation(pmRoot, collectMutationItemIds(result), {
-    background: !shouldRunSearchRefreshInForeground()
-  });
-  if (globalOptions.profile && refreshResult.warnings.length > 0) {
-    printError(`profile:search_refresh_warnings=${formatHookWarnings(refreshResult.warnings)}`);
-  }
-}
-
-export {
-  setResolvedGlobalOptions,
-  clearResolvedGlobalOptions,
-  getGlobalOptions,
-  getCommandPath,
-  applyDefaultOutputFormat,
-  collect,
-  readOptionString,
-  buildBackgroundTestCommandArgs,
-  buildBackgroundTestAllCommandArgs,
-  formatHookWarnings,
-  normalizeCreateOptions,
-  normalizeUpdateOptions,
-  extractUpdateManyMutationOptionSource,
-  normalizeListOptions,
-  normalizeAggregateOptions,
-  printListJsonStream,
-  printActivityJsonStream,
-  normalizeSearchOptions,
-  normalizeSearchKeywordsInput,
-  normalizeActivityOptions,
-  resolveActivityStreamMode,
-  normalizeContextOptions,
-  normalizeNextOptions,
-  invalidateSearchCachesForMutation
-};
-//# sourceMappingURL=chunk-4IWYTWGF.js.map
-
-//# debugId=3b942722-344b-5a0e-9629-7a60719de19e