@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-3VHSI5FL.js

@@ -0,0 +1,1001 @@
+
+!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]="c7b76be2-958a-52c6-890e-b9f04df75659")}catch(e){}}();
+import {
+  contentFiltersNeedBody,
+  contentFiltersNeedCollections,
+  hasContentFieldFilter,
+  itemMatchesContentFilters
+} from "./chunk-QB7XMHJW.js";
+import {
+  hasMissingMetadataFilter,
+  itemMatchesMissingMetadata,
+  lifecycleClassifierFromStatusRegistry
+} from "./chunk-MVYWGY2A.js";
+import {
+  parseIntegerLimit,
+  parsePriority,
+  parseType
+} from "./chunk-22KBU3MW.js";
+import {
+  HEAVY_METADATA_KEYS,
+  listAllFrontMatter,
+  listAllFrontMatterLight,
+  listAllFrontMatterWithBody,
+  toItemRecord
+} from "./chunk-ENGQOEUY.js";
+import {
+  coerceRuntimeFieldValue,
+  isTerminalStatus,
+  normalizeStatusInput,
+  readRuntimeFieldOptionValue
+} from "./chunk-G24G7ZAV.js";
+import {
+  compareTimestampStrings,
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  stableValueEquals
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  FRONT_MATTER_KEY_ORDER,
+  getSettingsPath,
+  levenshteinDistanceWithinLimit,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry
+} from "./chunk-57NWPFF2.js";
+
+// dist/core/item/status-filter.js
+var STATUS_GROUP_ALIASES = {
+  open: "open_status",
+  closed: "close_status",
+  canceled: "canceled_status",
+  cancelled: "canceled_status"
+};
+var STATUS_ALL_SENTINEL = "all";
+function isStatusAllFilterInput(raw) {
+  if (typeof raw !== "string") {
+    return false;
+  }
+  const tokens = raw.split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+  return tokens.length === 1 && tokens[0] === STATUS_ALL_SENTINEL;
+}
+function resolveStatusFilterToken(token, registry) {
+  const trimmed = token.trim().toLowerCase();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const group = STATUS_GROUP_ALIASES[trimmed];
+  if (group) {
+    return registry[group];
+  }
+  return normalizeStatusInput(token, registry);
+}
+function collectStatusSuggestionCandidates(registry) {
+  const candidates = new Set(Object.keys(STATUS_GROUP_ALIASES));
+  for (const definition of registry.definitions) {
+    candidates.add(definition.id);
+    for (const alias of definition.aliases) {
+      candidates.add(alias);
+    }
+  }
+  return [...candidates];
+}
+function suggestClosestStatus(value, registry) {
+  const normalized = value.trim().toLowerCase();
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const candidate of collectStatusSuggestionCandidates(registry)) {
+    const distance = levenshteinDistanceWithinLimit(normalized, candidate.toLowerCase(), 2);
+    if (distance !== null && distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function parseStatusFilterCsv(raw, registry, options) {
+  if (typeof raw !== "string") {
+    return void 0;
+  }
+  const strict = options?.strict === true;
+  const flagLabel = options?.flagLabel ?? "--status";
+  const tokens = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (tokens.length === 0) {
+    return void 0;
+  }
+  const allTokenCount = tokens.filter((token) => token.trim().toLowerCase() === STATUS_ALL_SENTINEL).length;
+  if (allTokenCount > 0) {
+    if (tokens.length === 1) {
+      return void 0;
+    }
+    throw new PmCliError(`Invalid ${flagLabel} value "all". Use it by itself, or omit ${flagLabel} to search every status.`, EXIT_CODE.USAGE);
+  }
+  const resolved = [];
+  for (const token of tokens) {
+    const status = resolveStatusFilterToken(token, registry);
+    if (status === void 0) {
+      if (strict) {
+        const suggestion = suggestClosestStatus(token, registry);
+        throw new PmCliError(`Invalid ${flagLabel} value "${token}". Use open|closed|canceled or a configured status id${suggestion ? `. Did you mean "${suggestion}"?` : "."}`, EXIT_CODE.USAGE);
+      }
+      resolved.push(token);
+      continue;
+    }
+    resolved.push(status);
+  }
+  return [...new Set(resolved)];
+}
+
+// dist/core/schema/runtime-field-filters.js
+function valuesEqual(left, right) {
+  return stableValueEquals(left, right);
+}
+function collectRuntimeFilterValues(options, fieldRegistry, command) {
+  const filters = {};
+  for (const definition of fieldRegistry.command_to_fields.get(command) ?? []) {
+    const rawValue = readRuntimeFieldOptionValue(options, definition);
+    if (rawValue === void 0) {
+      continue;
+    }
+    filters[definition.metadata_key] = coerceRuntimeFieldValue(definition, rawValue);
+  }
+  return filters;
+}
+function matchesRuntimeFilters(item, filters) {
+  for (const [fieldKey, expectedValue] of Object.entries(filters)) {
+    const actualValue = item[fieldKey];
+    if (Array.isArray(expectedValue)) {
+      if (Array.isArray(actualValue)) {
+        const normalizedActual = actualValue.map((value) => String(value));
+        const normalizedExpected = expectedValue.map((value) => String(value));
+        if (!normalizedExpected.every((value) => normalizedActual.includes(value))) {
+          return false;
+        }
+        continue;
+      }
+      if (!valuesEqual(actualValue, expectedValue[expectedValue.length - 1])) {
+        return false;
+      }
+      continue;
+    }
+    if (!valuesEqual(actualValue, expectedValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// dist/cli/commands/list.js
+function resolveMissingMetadataFilters(options) {
+  return {
+    acMissing: options.filterAcMissing === true,
+    estimatesMissing: options.filterEstimatesMissing === true,
+    resolutionMissing: options.filterResolutionMissing === true,
+    metadataMissing: options.filterMetadataMissing === true,
+    reviewerMissing: options.filterReviewerMissing === true,
+    riskMissing: options.filterRiskMissing === true,
+    confidenceMissing: options.filterConfidenceMissing === true,
+    sprintMissing: options.filterSprintMissing === true,
+    releaseMissing: options.filterReleaseMissing === true
+  };
+}
+var CONTENT_FIELD_FLAG_MAPPINGS = [
+  { field: "notes", presentKey: "hasNotes", absentKey: "noNotes", presentFlag: "--has-notes", absentFlag: "--no-notes" },
+  { field: "learnings", presentKey: "hasLearnings", absentKey: "noLearnings", presentFlag: "--has-learnings", absentFlag: "--no-learnings" },
+  { field: "files", presentKey: "hasFiles", absentKey: "noFiles", presentFlag: "--has-files", absentFlag: "--no-files" },
+  { field: "docs", presentKey: "hasDocs", absentKey: "noDocs", presentFlag: "--has-docs", absentFlag: "--no-docs" },
+  { field: "tests", presentKey: "hasTests", absentKey: "noTests", presentFlag: "--has-tests", absentFlag: "--no-tests" },
+  { field: "comments", presentKey: "hasComments", absentKey: "noComments", presentFlag: "--has-comments", absentFlag: "--no-comments" },
+  { field: "deps", presentKey: "hasDeps", absentKey: "noDeps", presentFlag: "--has-deps", absentFlag: "--no-deps" },
+  { field: "body", presentKey: "hasBody", absentKey: "emptyBody", presentFlag: "--has-body", absentFlag: "--empty-body" },
+  { field: "linked_command", presentKey: "hasLinkedCommand", absentKey: "noLinkedCommand", presentFlag: "--has-linked-command", absentFlag: "--no-linked-command" }
+];
+function resolveContentFieldFilters(options) {
+  const filters = {};
+  for (const mapping of CONTENT_FIELD_FLAG_MAPPINGS) {
+    const present = options[mapping.presentKey] === true;
+    const absent = options[mapping.absentKey] === true;
+    if (present && absent) {
+      throw new PmCliError(`Cannot combine ${mapping.presentFlag} with ${mapping.absentFlag} for the same field.`, EXIT_CODE.USAGE);
+    }
+    if (present) {
+      filters[mapping.field] = "present";
+    } else if (absent) {
+      filters[mapping.field] = "absent";
+    }
+  }
+  return filters;
+}
+var LIST_SORT_FIELDS = ["priority", "deadline", "updated_at", "created_at", "title", "parent"];
+var LIST_SORT_ORDER_VALUES = ["asc", "desc"];
+var DEFAULT_COMPACT_LIST_FIELDS = ["id", "title", "status", "type", "priority", "parent", "updated_at"];
+var BRIEF_LIST_FIELDS = ["id", "status", "type", "title"];
+var TREE_METADATA_FIELDS = ["tree_depth", "tree_parent", "tree_children", "tree_title"];
+var HEAVY_PROJECTION_FIELDS = new Set(HEAVY_METADATA_KEYS);
+function isNonEmptyRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+var CONTENT_FILTER_ECHO_ENTRIES = [
+  { key: "hasNotes", summaryKey: "has_notes" },
+  { key: "hasLearnings", summaryKey: "has_learnings" },
+  { key: "hasFiles", summaryKey: "has_files" },
+  { key: "hasDocs", summaryKey: "has_docs" },
+  { key: "hasTests", summaryKey: "has_tests" },
+  { key: "hasComments", summaryKey: "has_comments" },
+  { key: "hasDeps", summaryKey: "has_deps" },
+  { key: "hasBody", summaryKey: "has_body" },
+  { key: "hasLinkedCommand", summaryKey: "has_linked_command" },
+  { key: "noNotes", summaryKey: "no_notes" },
+  { key: "noLearnings", summaryKey: "no_learnings" },
+  { key: "noFiles", summaryKey: "no_files" },
+  { key: "noDocs", summaryKey: "no_docs" },
+  { key: "noTests", summaryKey: "no_tests" },
+  { key: "noComments", summaryKey: "no_comments" },
+  { key: "noDeps", summaryKey: "no_deps" },
+  { key: "emptyBody", summaryKey: "empty_body" },
+  { key: "noLinkedCommand", summaryKey: "no_linked_command" }
+];
+var GOVERNANCE_MISSING_ECHO_ENTRIES = [
+  { key: "filterReviewerMissing", summaryKey: "filter_reviewer_missing" },
+  { key: "filterRiskMissing", summaryKey: "filter_risk_missing" },
+  { key: "filterConfidenceMissing", summaryKey: "filter_confidence_missing" },
+  { key: "filterSprintMissing", summaryKey: "filter_sprint_missing" },
+  { key: "filterReleaseMissing", summaryKey: "filter_release_missing" }
+];
+function applyContentFilterEcho(filters, options) {
+  for (const entry of CONTENT_FILTER_ECHO_ENTRIES) {
+    if (options[entry.key] === true) {
+      filters[entry.summaryKey] = true;
+    }
+  }
+}
+function applyGovernanceMissingFilterEcho(filters, options) {
+  for (const entry of GOVERNANCE_MISSING_ECHO_ENTRIES) {
+    if (options[entry.key] === true) {
+      filters[entry.summaryKey] = true;
+    }
+  }
+}
+function applyFilterValueEcho(filters, options, entries) {
+  for (const entry of entries) {
+    const value = options[entry.optionKey];
+    if (value !== void 0) {
+      filters[entry.summaryKey] = entry.normalize ? entry.normalize(value) : value;
+    }
+  }
+}
+function buildContentFilterEcho(options) {
+  const echo = {};
+  applyContentFilterEcho(echo, options);
+  return echo;
+}
+function buildGovernanceMissingFilterEcho(options) {
+  const echo = {};
+  applyGovernanceMissingFilterEcho(echo, options);
+  return echo;
+}
+var COMPACT_LIST_VALUE_FILTER_ECHO_ENTRIES = [
+  { optionKey: "type", summaryKey: "type" },
+  { optionKey: "tag", summaryKey: "tag" },
+  { optionKey: "priority", summaryKey: "priority" },
+  { optionKey: "deadlineBefore", summaryKey: "deadline_before" },
+  { optionKey: "deadlineAfter", summaryKey: "deadline_after" },
+  { optionKey: "updatedAfter", summaryKey: "updated_after" },
+  { optionKey: "updatedBefore", summaryKey: "updated_before" },
+  { optionKey: "createdAfter", summaryKey: "created_after" },
+  { optionKey: "createdBefore", summaryKey: "created_before" },
+  { optionKey: "ids", summaryKey: "ids" },
+  { optionKey: "assignee", summaryKey: "assignee" },
+  { optionKey: "assigneeFilter", summaryKey: "assignee_filter" },
+  { optionKey: "parent", summaryKey: "parent" },
+  { optionKey: "sprint", summaryKey: "sprint" },
+  { optionKey: "release", summaryKey: "release" }
+];
+var VERBOSE_LIST_VALUE_FILTER_ECHO_ENTRIES = [
+  { optionKey: "type", summaryKey: "type" },
+  { optionKey: "tag", summaryKey: "tag" },
+  { optionKey: "priority", summaryKey: "priority" },
+  { optionKey: "deadlineBefore", summaryKey: "deadline_before" },
+  { optionKey: "deadlineAfter", summaryKey: "deadline_after" },
+  { optionKey: "updatedAfter", summaryKey: "updated_after" },
+  { optionKey: "updatedBefore", summaryKey: "updated_before" },
+  { optionKey: "createdAfter", summaryKey: "created_after" },
+  { optionKey: "createdBefore", summaryKey: "created_before" },
+  { optionKey: "ids", summaryKey: "ids" },
+  { optionKey: "assignee", summaryKey: "assignee" },
+  { optionKey: "assigneeFilter", summaryKey: "assignee_filter" },
+  { optionKey: "parent", summaryKey: "parent" },
+  { optionKey: "sprint", summaryKey: "sprint" },
+  { optionKey: "release", summaryKey: "release" },
+  { optionKey: "limit", summaryKey: "limit" },
+  { optionKey: "offset", summaryKey: "offset" },
+  { optionKey: "includeBody", summaryKey: "include_body" },
+  { optionKey: "compact", summaryKey: "compact" },
+  { optionKey: "fields", summaryKey: "fields" }
+];
+var VERBOSE_LIST_BOOLEAN_FILTER_ECHO_ENTRIES = [
+  { key: "filterAcMissing", summaryKey: "filter_ac_missing" },
+  { key: "filterEstimatesMissing", summaryKey: "filter_estimates_missing" },
+  { key: "filterResolutionMissing", summaryKey: "filter_resolution_missing" },
+  { key: "filterMetadataMissing", summaryKey: "filter_metadata_missing" }
+];
+function buildCompactListFilterSummary(params) {
+  const { filtersStatus, options, treeEnabled, treeDepth, sortField, sortOrder, runtimeFieldFilters } = params;
+  const filters = {};
+  if (filtersStatus !== null) {
+    filters.status = filtersStatus;
+  }
+  applyFilterValueEcho(filters, options, COMPACT_LIST_VALUE_FILTER_ECHO_ENTRIES);
+  if (options.filterAcMissing === true) {
+    filters.filter_ac_missing = true;
+  }
+  if (options.filterEstimatesMissing === true) {
+    filters.filter_estimates_missing = true;
+  }
+  if (options.filterResolutionMissing === true) {
+    filters.filter_resolution_missing = true;
+  }
+  if (options.filterMetadataMissing === true) {
+    filters.filter_metadata_missing = true;
+  }
+  applyGovernanceMissingFilterEcho(filters, options);
+  applyContentFilterEcho(filters, options);
+  if (options.limit !== void 0) {
+    filters.limit = options.limit;
+  }
+  if (options.offset !== void 0) {
+    filters.offset = options.offset;
+  }
+  if (options.includeBody === true) {
+    filters.include_body = true;
+  }
+  if (options.fields !== void 0) {
+    filters.fields = options.fields;
+  }
+  if (treeEnabled) {
+    filters.tree = true;
+    if (treeDepth !== void 0) {
+      filters.tree_depth = treeDepth;
+    }
+  }
+  if (sortField !== void 0) {
+    filters.sort = sortField;
+    filters.order = sortOrder;
+  }
+  if (isNonEmptyRecord(runtimeFieldFilters)) {
+    filters.runtime_filters = runtimeFieldFilters;
+  }
+  return filters;
+}
+function compareDefaultSort(left, right, statusRegistry) {
+  const leftTerminal = isTerminalStatus(left.status, statusRegistry);
+  const rightTerminal = isTerminalStatus(right.status, statusRegistry);
+  if (leftTerminal !== rightTerminal) {
+    return leftTerminal ? 1 : -1;
+  }
+  const byPriority = left.priority - right.priority;
+  if (byPriority !== 0) {
+    return byPriority;
+  }
+  const byUpdated = compareTimestampStrings(right.updated_at, left.updated_at);
+  if (byUpdated !== 0) {
+    return byUpdated;
+  }
+  return (left.id ?? "").localeCompare(right.id ?? "");
+}
+function sortItemsDefault(items, statusRegistry) {
+  return [...items].sort((left, right) => compareDefaultSort(left, right, statusRegistry));
+}
+function parseDeadline(raw, fieldLabel) {
+  if (raw === void 0)
+    return void 0;
+  return resolveIsoOrRelative(raw, /* @__PURE__ */ new Date(), fieldLabel);
+}
+function parseTimestampWindow(raw, fieldLabel) {
+  if (raw == null)
+    return void 0;
+  const value = String(raw).trim();
+  if (value.length === 0)
+    return void 0;
+  return resolveIsoOrRelative(value, /* @__PURE__ */ new Date(), fieldLabel);
+}
+function parseIdsFilter(raw) {
+  if (raw == null)
+    return void 0;
+  const value = String(raw).trim();
+  if (value.length === 0) {
+    throw new PmCliError("--ids requires at least one non-empty item ID", EXIT_CODE.USAGE);
+  }
+  const ids = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (ids.length === 0) {
+    throw new PmCliError("--ids requires at least one non-empty item ID", EXIT_CODE.USAGE);
+  }
+  return new Set(ids);
+}
+function parseOffset(raw) {
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new PmCliError("Offset filter must be a non-negative integer", EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseFieldSelectors(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const selectors = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (selectors.length === 0) {
+    throw new PmCliError("List --fields requires a comma-separated list of field names", EXIT_CODE.USAGE);
+  }
+  return [...new Set(selectors)];
+}
+function parseProjectionConfig(options) {
+  const compactRequested = options.compact === true;
+  const briefRequested = options.brief === true;
+  const fullRequested = options.full === true;
+  const fieldSelectors = parseFieldSelectors(options.fields);
+  const enabledModes = Number(compactRequested) + Number(briefRequested) + Number(fullRequested) + Number(fieldSelectors !== void 0);
+  if (enabledModes > 1) {
+    throw new PmCliError("List projection options are mutually exclusive. Use one of --compact, --brief, --full, or --fields.", EXIT_CODE.USAGE);
+  }
+  if (fullRequested) {
+    return {
+      mode: "full",
+      fields: []
+    };
+  }
+  if (briefRequested) {
+    return {
+      mode: "compact",
+      fields: [...BRIEF_LIST_FIELDS]
+    };
+  }
+  if (compactRequested) {
+    return {
+      mode: "compact",
+      fields: [...DEFAULT_COMPACT_LIST_FIELDS]
+    };
+  }
+  if (fieldSelectors) {
+    return {
+      mode: "fields",
+      fields: fieldSelectors
+    };
+  }
+  return {
+    mode: "full",
+    fields: []
+  };
+}
+function normalizeProjectionField(field) {
+  return field.startsWith("item.") ? field.slice("item.".length) : field;
+}
+function validateListProjectionFields(projection, runtimeMetadataKeys) {
+  if (projection.mode !== "fields") {
+    return;
+  }
+  const allowed = /* @__PURE__ */ new Set([...FRONT_MATTER_KEY_ORDER, "body", ...TREE_METADATA_FIELDS, ...runtimeMetadataKeys]);
+  const unknown = projection.fields.filter((field) => !allowed.has(normalizeProjectionField(field)));
+  if (unknown.length > 0) {
+    throw new PmCliError(`Unknown list --fields value(s): ${unknown.join(", ")}`, EXIT_CODE.USAGE, {
+      code: "unknown_field_projection",
+      examples: [
+        "pm list-open --fields id,title,status,type,updated_at",
+        "pm list --fields id,title,parent,priority --limit 10",
+        "pm list-all --fields id,title,body --limit 5"
+      ]
+    });
+  }
+}
+var LIST_SORT_FIELD_ALIASES = /* @__PURE__ */ new Map([
+  ["updated", "updated_at"],
+  ["update", "updated_at"],
+  ["modified", "updated_at"],
+  ["created", "created_at"],
+  ["create", "created_at"]
+]);
+function parseSortField(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase();
+  const aliased = LIST_SORT_FIELD_ALIASES.get(normalized);
+  if (aliased) {
+    return aliased;
+  }
+  if (!LIST_SORT_FIELDS.includes(normalized)) {
+    throw new PmCliError(`Sort field must be one of ${LIST_SORT_FIELDS.join("|")} (aliases: updated->updated_at, created->created_at)`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseSortOrder(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (!LIST_SORT_ORDER_VALUES.includes(normalized)) {
+    throw new PmCliError(`Sort order must be one of ${LIST_SORT_ORDER_VALUES.join("|")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseTreeDepth(raw) {
+  return parseIntegerLimit(raw, "--tree-depth");
+}
+function parseAssigneeFilter(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized) {
+    throw new PmCliError("Assignee filter must be one of assigned|unassigned", EXIT_CODE.USAGE);
+  }
+  if (normalized !== "assigned" && normalized !== "unassigned") {
+    throw new PmCliError(`Invalid assignee filter "${raw}". Allowed: assigned|unassigned`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function resolveStatusFilter(status, statusRegistry) {
+  return parseStatusFilterCsv(status, statusRegistry, { strict: false });
+}
+function assertListAssigneeFilters(assigneeFilter, assigneeModeFilter) {
+  if (assigneeFilter && (assigneeFilter.toLowerCase() === "none" || assigneeFilter.toLowerCase() === "null")) {
+    throw new PmCliError('--assignee no longer accepts "none" or "null". Use --assignee-filter unassigned.', EXIT_CODE.USAGE);
+  }
+  if (assigneeFilter !== void 0 && assigneeModeFilter === "unassigned") {
+    throw new PmCliError("Cannot combine --assignee with --assignee-filter unassigned", EXIT_CODE.USAGE);
+  }
+}
+function resolveListFilterSet(status, options, typeRegistry, statusRegistry) {
+  const assigneeFilter = options.assignee?.trim();
+  const assigneeModeFilter = parseAssigneeFilter(options.assigneeFilter);
+  assertListAssigneeFilters(assigneeFilter, assigneeModeFilter);
+  const missingMetadataFilters = resolveMissingMetadataFilters(options);
+  const contentFieldFilters = resolveContentFieldFilters(options);
+  return {
+    idsFilter: parseIdsFilter(options.ids),
+    statusSet: status && status.length > 0 ? new Set(status) : void 0,
+    excludeTerminal: options.excludeTerminal === true,
+    typeFilter: parseType(options.type, typeRegistry),
+    tagFilter: options.tag?.trim().toLowerCase(),
+    priorityFilter: parsePriority(options.priority),
+    deadlineBefore: parseDeadline(options.deadlineBefore, "deadline-before"),
+    deadlineAfter: parseDeadline(options.deadlineAfter, "deadline-after"),
+    updatedAfter: parseTimestampWindow(options.updatedAfter, "updated-after"),
+    updatedBefore: parseTimestampWindow(options.updatedBefore, "updated-before"),
+    createdAfter: parseTimestampWindow(options.createdAfter, "created-after"),
+    createdBefore: parseTimestampWindow(options.createdBefore, "created-before"),
+    assigneeFilter,
+    assigneeModeFilter,
+    parentFilter: options.parent?.trim(),
+    treeEnabled: options.tree === true,
+    sprintFilter: options.sprint?.trim(),
+    releaseFilter: options.release?.trim(),
+    missingMetadataFilters,
+    missingMetadataActive: hasMissingMetadataFilter(missingMetadataFilters),
+    lifecycleClassifier: lifecycleClassifierFromStatusRegistry(statusRegistry),
+    contentFieldFilters,
+    contentFiltersActive: hasContentFieldFilter(contentFieldFilters)
+  };
+}
+function matchesListScalarFilters(item, filters, statusRegistry) {
+  return matchesListIdentityFilters(item, filters, statusRegistry) && matchesListDateFilters(item, filters) && matchesListAssigneeFilterSet(item, filters) && matchesListScopeFilters(item, filters);
+}
+function matchesListIdentityFilters(item, filters, statusRegistry) {
+  if (filters.idsFilter && !filters.idsFilter.has(item.id))
+    return false;
+  if (filters.statusSet && !filters.statusSet.has(item.status))
+    return false;
+  if (filters.excludeTerminal && isTerminalStatus(item.status, statusRegistry))
+    return false;
+  if (filters.typeFilter && item.type !== filters.typeFilter)
+    return false;
+  if (filters.tagFilter && !(item.tags ?? []).includes(filters.tagFilter))
+    return false;
+  return filters.priorityFilter === void 0 || item.priority === filters.priorityFilter;
+}
+function matchesListDateFilters(item, filters) {
+  if (filters.deadlineBefore && (!item.deadline || compareTimestampStrings(item.deadline, filters.deadlineBefore) > 0))
+    return false;
+  if (filters.deadlineAfter && (!item.deadline || compareTimestampStrings(item.deadline, filters.deadlineAfter) < 0))
+    return false;
+  if (filters.updatedAfter && compareTimestampStrings(item.updated_at, filters.updatedAfter) < 0)
+    return false;
+  if (filters.updatedBefore && compareTimestampStrings(item.updated_at, filters.updatedBefore) > 0)
+    return false;
+  if (filters.createdAfter && compareTimestampStrings(item.created_at, filters.createdAfter) < 0)
+    return false;
+  return !filters.createdBefore || compareTimestampStrings(item.created_at, filters.createdBefore) <= 0;
+}
+function matchesListAssigneeFilterSet(item, filters) {
+  if (filters.assigneeModeFilter === "assigned" && !item.assignee)
+    return false;
+  if (filters.assigneeModeFilter === "unassigned" && item.assignee)
+    return false;
+  return filters.assigneeFilter === void 0 || item.assignee === filters.assigneeFilter;
+}
+function matchesListScopeFilters(item, filters) {
+  if (filters.parentFilter !== void 0 && !filters.treeEnabled && item.parent !== filters.parentFilter)
+    return false;
+  if (filters.sprintFilter !== void 0 && item.sprint !== filters.sprintFilter)
+    return false;
+  return filters.releaseFilter === void 0 || item.release === filters.releaseFilter;
+}
+function matchesListFilterSet(item, filters, statusRegistry, runtimeFieldFilters) {
+  if (!matchesListScalarFilters(item, filters, statusRegistry)) {
+    return false;
+  }
+  if (filters.missingMetadataActive && !itemMatchesMissingMetadata(item, filters.missingMetadataFilters, filters.lifecycleClassifier)) {
+    return false;
+  }
+  if (filters.contentFiltersActive && !itemMatchesContentFilters(item, filters.contentFieldFilters)) {
+    return false;
+  }
+  if (!matchesRuntimeFilters(item, runtimeFieldFilters)) {
+    return false;
+  }
+  return true;
+}
+function applyFilters(items, status, options, typeRegistry, statusRegistry, runtimeFieldFilters) {
+  const filters = resolveListFilterSet(status, options, typeRegistry, statusRegistry);
+  return items.filter((item) => matchesListFilterSet(item, filters, statusRegistry, runtimeFieldFilters));
+}
+function trimNonEmpty(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function withTreeMetadata(item, depth, childCount) {
+  const itemRecord = toItemRecord(item);
+  const title = typeof itemRecord.title === "string" ? itemRecord.title : "";
+  const parent = trimNonEmpty(typeof itemRecord.parent === "string" ? itemRecord.parent : void 0) ?? null;
+  return {
+    ...item,
+    tree_depth: depth,
+    tree_parent: parent,
+    tree_children: childCount,
+    tree_title: `${"  ".repeat(depth)}${title}`
+  };
+}
+function orderItemsAsTree(sortedItems, parentRoot, maxDepth) {
+  const byId = /* @__PURE__ */ new Map();
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const item of sortedItems) {
+    byId.set(item.id, item);
+    const parentId = trimNonEmpty(item.parent);
+    if (!parentId) {
+      continue;
+    }
+    const bucket = childrenByParent.get(parentId);
+    if (bucket) {
+      bucket.push(item);
+    } else {
+      childrenByParent.set(parentId, [item]);
+    }
+  }
+  const roots = parentRoot ? [...childrenByParent.get(parentRoot) ?? []] : sortedItems.filter((item) => {
+    const parentId = trimNonEmpty(item.parent);
+    return !parentId || !byId.has(parentId);
+  });
+  const ordered = [];
+  const visited = /* @__PURE__ */ new Set();
+  const pushNode = (node, depth) => {
+    if (visited.has(node.id)) {
+      return;
+    }
+    visited.add(node.id);
+    const children = childrenByParent.get(node.id) ?? [];
+    ordered.push(withTreeMetadata(node, depth, children.length));
+    if (maxDepth !== void 0 && depth >= maxDepth) {
+      return;
+    }
+    for (const child of children) {
+      pushNode(child, depth + 1);
+    }
+  };
+  for (const root of roots) {
+    pushNode(root, 0);
+  }
+  return ordered;
+}
+function compareNullableString(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  if (left === null) {
+    return 1;
+  }
+  if (right === null) {
+    return -1;
+  }
+  return left.localeCompare(right);
+}
+function compareNullableTimestamp(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  if (left === null) {
+    return 1;
+  }
+  if (right === null) {
+    return -1;
+  }
+  return compareTimestampStrings(left, right);
+}
+function compareBySortField(left, right, field) {
+  switch (field) {
+    case "priority":
+      return left.priority - right.priority;
+    case "deadline":
+      return compareNullableTimestamp(left.deadline ?? null, right.deadline ?? null);
+    case "updated_at":
+      return compareTimestampStrings(left.updated_at, right.updated_at);
+    case "created_at":
+      return compareTimestampStrings(left.created_at, right.created_at);
+    case "title":
+      return (left.title ?? "").localeCompare(right.title ?? "");
+    case "parent":
+      return compareNullableString(left.parent ?? null, right.parent ?? null);
+    default:
+      return 0;
+  }
+}
+function sortItems(items, sortField, sortOrder, statusRegistry) {
+  if (!sortField) {
+    return sortItemsDefault(items, statusRegistry);
+  }
+  return [...items].sort((left, right) => {
+    const byField = compareBySortField(left, right, sortField);
+    if (byField !== 0) {
+      return sortOrder === "desc" ? -byField : byField;
+    }
+    const fallback = compareDefaultSort(left, right, statusRegistry);
+    return sortOrder === "desc" ? -fallback : fallback;
+  });
+}
+function readListFieldValue(item, field, treeMode = false) {
+  const normalized = normalizeProjectionField(field.trim());
+  if (normalized.length === 0) {
+    return null;
+  }
+  const itemRecord = toItemRecord(item);
+  if (treeMode && normalized === "title" && typeof itemRecord.tree_title === "string") {
+    return itemRecord.tree_title;
+  }
+  if (Object.prototype.hasOwnProperty.call(itemRecord, normalized)) {
+    return itemRecord[normalized] ?? null;
+  }
+  return null;
+}
+function projectListItems(items, projection, treeMode = false) {
+  if (projection.mode === "full") {
+    return items;
+  }
+  return items.map((item) => {
+    const projected = {};
+    for (const field of projection.fields) {
+      projected[field] = readListFieldValue(item, field, treeMode);
+    }
+    return projected;
+  });
+}
+function runtimeMetadataKeysForProjection(definitions) {
+  const keys = [];
+  for (const field of definitions) {
+    keys.push(field.metadata_key);
+  }
+  return keys;
+}
+async function resolveListRuntimeContext(options, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const settings = await readSettings(pmRoot);
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const projection = parseProjectionConfig(options);
+  validateListProjectionFields(projection, runtimeMetadataKeysForProjection(runtimeFieldRegistry.definitions));
+  return {
+    pmRoot,
+    settings,
+    statusRegistry,
+    runtimeFieldFilters: collectRuntimeFilterValues(options, runtimeFieldRegistry, "list"),
+    typeRegistry: resolveItemTypeRegistry(settings, getActiveExtensionRegistrations()),
+    projection
+  };
+}
+async function loadListItems(options, runtime, listWarnings) {
+  const projectionNeedsBody = runtime.projection.fields.some((field) => normalizeProjectionField(field) === "body");
+  const projectionNeedsCollections = runtime.projection.mode === "full" || runtime.projection.fields.some((field) => HEAVY_PROJECTION_FIELDS.has(normalizeProjectionField(field)));
+  const contentFieldFilters = resolveContentFieldFilters(options);
+  const contentNeedsCollections = contentFiltersNeedCollections(contentFieldFilters);
+  const contentNeedsBody = contentFiltersNeedBody(contentFieldFilters);
+  if (options.includeBody || projectionNeedsBody || contentNeedsBody) {
+    return await listAllFrontMatterWithBody(runtime.pmRoot, runtime.settings.item_format, runtime.typeRegistry.type_to_folder, listWarnings, runtime.settings.schema);
+  }
+  if (projectionNeedsCollections || contentNeedsCollections) {
+    return await listAllFrontMatter(runtime.pmRoot, runtime.settings.item_format, runtime.typeRegistry.type_to_folder, listWarnings, runtime.settings.schema);
+  }
+  return await listAllFrontMatterLight(runtime.pmRoot, runtime.settings.item_format, runtime.typeRegistry.type_to_folder, listWarnings, runtime.settings.schema);
+}
+function resolveListOrderingOptions(options) {
+  const sortField = parseSortField(options.sort);
+  const sortOrder = parseSortOrder(options.order) ?? "asc";
+  const treeEnabled = options.tree === true;
+  if (!treeEnabled && options.treeDepth !== void 0) {
+    throw new PmCliError("List --tree-depth requires --tree", EXIT_CODE.USAGE);
+  }
+  if (!sortField && options.order !== void 0) {
+    throw new PmCliError("List --order requires --sort", EXIT_CODE.USAGE);
+  }
+  return {
+    sortField,
+    sortOrder,
+    treeEnabled,
+    treeDepth: treeEnabled ? parseTreeDepth(options.treeDepth) : void 0,
+    parentRoot: treeEnabled ? trimNonEmpty(options.parent) : void 0
+  };
+}
+function resolveListStatusSelection(status, options, statusRegistry) {
+  const explicitStatus = resolveStatusFilter(options.status, statusRegistry);
+  const resolvedStatus = explicitStatus ?? resolveStatusFilter(status, statusRegistry);
+  const explicitAllStatuses = isStatusAllFilterInput(options.status);
+  const effectiveOptions = explicitStatus || explicitAllStatuses ? { ...options, excludeTerminal: false } : options;
+  const filtersStatus = explicitAllStatuses ? "all" : resolvedStatus === void 0 ? null : resolvedStatus.length === 1 ? resolvedStatus[0] : resolvedStatus;
+  return { resolvedStatus, explicitAllStatuses, effectiveOptions, filtersStatus };
+}
+function pageAndProjectListItems(ordered, options, projection, treeEnabled) {
+  const noTruncate = options.noTruncate === true;
+  const limit = noTruncate ? void 0 : parseIntegerLimit(options.limit);
+  const offset = parseOffset(options.offset) ?? 0;
+  const limited = limit === void 0 ? ordered.slice(offset) : ordered.slice(offset, offset + limit);
+  const projected = projectListItems(limited, projection, treeEnabled);
+  const totalMatched = ordered.length;
+  return {
+    projected,
+    totalMatched,
+    truncationExtras: projected.length < totalMatched ? { total: totalMatched } : {}
+  };
+}
+function buildVerboseListFilters(params) {
+  const { filtersStatus, options, noTruncate, treeEnabled, treeDepth, sortField, sortOrder, runtimeFieldFilters } = params;
+  const filters = { status: filtersStatus };
+  const optionRecord = options;
+  for (const entry of VERBOSE_LIST_VALUE_FILTER_ECHO_ENTRIES) {
+    filters[entry.summaryKey] = optionRecord[entry.optionKey] ?? null;
+  }
+  for (const entry of VERBOSE_LIST_BOOLEAN_FILTER_ECHO_ENTRIES) {
+    if (optionRecord[entry.key] === true) {
+      filters[entry.summaryKey] = true;
+    }
+  }
+  Object.assign(filters, buildGovernanceMissingFilterEcho(options), buildContentFilterEcho(options));
+  if (noTruncate) {
+    filters.no_truncate = true;
+  }
+  if (treeEnabled) {
+    filters.tree = true;
+    filters.tree_depth = treeDepth ?? null;
+  }
+  filters.sort = sortField ?? null;
+  filters.order = sortField ? sortOrder : null;
+  filters.runtime_filters = runtimeFieldFilters;
+  return filters;
+}
+async function runList(status, options, global) {
+  const runtime = await resolveListRuntimeContext(options, global);
+  const listWarnings = [];
+  const items = await loadListItems(options, runtime, listWarnings);
+  const ordering = resolveListOrderingOptions(options);
+  const statusSelection = resolveListStatusSelection(status, options, runtime.statusRegistry);
+  const filtered = applyFilters(items, statusSelection.resolvedStatus, statusSelection.effectiveOptions, runtime.typeRegistry, runtime.statusRegistry, runtime.runtimeFieldFilters);
+  const sorted = sortItems(filtered, ordering.sortField, ordering.sortOrder, runtime.statusRegistry);
+  const ordered = ordering.treeEnabled ? orderItemsAsTree(sorted, ordering.parentRoot, ordering.treeDepth) : sorted;
+  const noTruncate = options.noTruncate === true;
+  const page = pageAndProjectListItems(ordered, options, runtime.projection, ordering.treeEnabled);
+  const now = nowIso();
+  const warnings = [...new Set(listWarnings)].sort((left, right) => left.localeCompare(right));
+  const projectionFields = runtime.projection.mode === "full" ? null : [...runtime.projection.fields];
+  const compactSummaryMode = runtime.projection.mode === "compact" && options.compact === true;
+  if (compactSummaryMode) {
+    const compactFilters = buildCompactListFilterSummary({
+      filtersStatus: statusSelection.filtersStatus,
+      options,
+      treeEnabled: ordering.treeEnabled,
+      treeDepth: ordering.treeDepth,
+      sortField: ordering.sortField,
+      sortOrder: ordering.sortOrder,
+      runtimeFieldFilters: runtime.runtimeFieldFilters
+    });
+    return {
+      items: page.projected,
+      count: page.projected.length,
+      ...page.truncationExtras,
+      filters: compactFilters,
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  }
+  return {
+    items: page.projected,
+    count: page.projected.length,
+    ...page.truncationExtras,
+    filters: buildVerboseListFilters({
+      filtersStatus: statusSelection.filtersStatus,
+      options,
+      noTruncate,
+      treeEnabled: ordering.treeEnabled,
+      treeDepth: ordering.treeDepth,
+      sortField: ordering.sortField,
+      sortOrder: ordering.sortOrder,
+      runtimeFieldFilters: runtime.runtimeFieldFilters
+    }),
+    projection: {
+      mode: runtime.projection.mode,
+      fields: projectionFields
+    },
+    sorting: {
+      sort: ordering.sortField ?? "default",
+      order: ordering.sortField ? ordering.sortOrder : "asc"
+    },
+    now,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+var _testOnly = {
+  applyFilters,
+  buildCompactListFilterSummary,
+  buildContentFilterEcho,
+  buildGovernanceMissingFilterEcho,
+  resolveContentFieldFilters,
+  resolveMissingMetadataFilters,
+  compareBySortField,
+  compareDefaultSort,
+  compareNullableString,
+  compareNullableTimestamp,
+  normalizeProjectionField,
+  parseAssigneeFilter,
+  parseFieldSelectors,
+  parseIdsFilter,
+  parseOffset,
+  parseProjectionConfig,
+  parseSortField,
+  parseSortOrder,
+  orderItemsAsTree,
+  projectListItems,
+  readListFieldValue,
+  runtimeMetadataKeysForProjection,
+  sortItems,
+  trimNonEmpty,
+  withTreeMetadata
+};
+
+export {
+  isStatusAllFilterInput,
+  parseStatusFilterCsv,
+  collectRuntimeFilterValues,
+  matchesRuntimeFilters,
+  resolveMissingMetadataFilters,
+  resolveContentFieldFilters,
+  LIST_SORT_FIELDS,
+  LIST_SORT_ORDER_VALUES,
+  applyFilterValueEcho,
+  buildContentFilterEcho,
+  buildGovernanceMissingFilterEcho,
+  runList,
+  _testOnly
+};
+//# sourceMappingURL=chunk-3VHSI5FL.js.map
+
+//# debugId=c7b76be2-958a-52c6-890e-b9f04df75659