@unbrained/pm-cli 2026.6.13 → 2026.6.16

package/dist/cli-bundle/chunks/chunk-7EILPFMA.js

@@ -0,0 +1,404 @@
+import {
+  toNonEmptyStringOrUndefined
+} from "./chunk-LV5FFQ7M.js";
+
+// dist/core/governance/metadata-coverage.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "53dbd46b-5d5b-56ac-9e84-8139d30d84ac");
+  } catch (e2) {
+  }
+})();
+function normalizeStatus(status, registry) {
+  const trimmed = status.trim().toLowerCase();
+  return registry.alias_to_id.get(trimmed) ?? trimmed;
+}
+function lifecycleClassifierFromStatusRegistry(registry) {
+  return {
+    isTerminal(status) {
+      return registry.terminal_statuses.has(normalizeStatus(status, registry));
+    },
+    classify(status) {
+      const id = normalizeStatus(status, registry);
+      if (registry.terminal_canceled_statuses.has(id)) {
+        return "canceled";
+      }
+      if (registry.terminal_statuses.has(id)) {
+        return "closed";
+      }
+      if (registry.blocked_statuses.has(id)) {
+        return "blocked";
+      }
+      if (registry.draft_statuses.has(id)) {
+        return "draft";
+      }
+      if (id === registry.open_status) {
+        return "open";
+      }
+      if (registry.active_statuses.has(id)) {
+        return "in_progress";
+      }
+      return "other";
+    }
+  };
+}
+function isAcMissing(item) {
+  return toNonEmptyStringOrUndefined(item.acceptance_criteria) === void 0;
+}
+function isEstimateMissing(item) {
+  return !Number.isFinite(item.estimated_minutes);
+}
+function isResolutionMissing(item, classifier) {
+  if (!classifier.isTerminal(item.status)) {
+    return false;
+  }
+  return toNonEmptyStringOrUndefined(item.resolution) === void 0;
+}
+function isReviewerMissing(item) {
+  return toNonEmptyStringOrUndefined(item.reviewer) === void 0;
+}
+function isRiskMissing(item) {
+  return toNonEmptyStringOrUndefined(item.risk) === void 0;
+}
+function isConfidenceMissing(item) {
+  if (typeof item.confidence === "number") {
+    return !Number.isFinite(item.confidence);
+  }
+  return toNonEmptyStringOrUndefined(item.confidence) === void 0;
+}
+function isSprintMissing(item) {
+  return toNonEmptyStringOrUndefined(item.sprint) === void 0;
+}
+function isReleaseMissing(item) {
+  return toNonEmptyStringOrUndefined(item.release) === void 0;
+}
+function hasMissingMetadataFilter(filters) {
+  return Boolean(filters.acMissing || filters.estimatesMissing || filters.resolutionMissing || filters.reviewerMissing || filters.riskMissing || filters.confidenceMissing || filters.sprintMissing || filters.releaseMissing || filters.metadataMissing);
+}
+function itemMatchesMissingMetadata(item, filters, classifier) {
+  if (!hasMissingMetadataFilter(filters)) {
+    return true;
+  }
+  if (filters.acMissing && !isAcMissing(item)) {
+    return false;
+  }
+  if (filters.estimatesMissing && !isEstimateMissing(item)) {
+    return false;
+  }
+  if (filters.resolutionMissing && !isResolutionMissing(item, classifier)) {
+    return false;
+  }
+  if (filters.reviewerMissing && !isReviewerMissing(item)) {
+    return false;
+  }
+  if (filters.riskMissing && !isRiskMissing(item)) {
+    return false;
+  }
+  if (filters.confidenceMissing && !isConfidenceMissing(item)) {
+    return false;
+  }
+  if (filters.sprintMissing && !isSprintMissing(item)) {
+    return false;
+  }
+  if (filters.releaseMissing && !isReleaseMissing(item)) {
+    return false;
+  }
+  if (filters.metadataMissing) {
+    const anyMissing = isAcMissing(item) || isEstimateMissing(item) || isResolutionMissing(item, classifier);
+    if (!anyMissing) {
+      return false;
+    }
+  }
+  return true;
+}
+var COVERAGE_FIELD_ORDER = [
+  "acceptance_criteria",
+  "estimated_minutes",
+  "resolution",
+  "tags",
+  "parent"
+];
+function isFieldPresent(item, field) {
+  switch (field) {
+    case "acceptance_criteria":
+      return !isAcMissing(item);
+    case "estimated_minutes":
+      return !isEstimateMissing(item);
+    case "resolution":
+      return toNonEmptyStringOrUndefined(item.resolution) !== void 0;
+    case "tags":
+      return Array.isArray(item.tags) && item.tags.length > 0;
+    default:
+      return toNonEmptyStringOrUndefined(item.parent) !== void 0;
+  }
+}
+function isFieldApplicable(item, field, classifier) {
+  if (field === "resolution") {
+    return classifier.isTerminal(item.status);
+  }
+  return true;
+}
+function roundPercent(present, applicable) {
+  if (applicable === 0) {
+    return 100;
+  }
+  return Math.round(present / applicable * 1e3) / 10;
+}
+function emptyFieldCoverage() {
+  const record = {};
+  for (const field of COVERAGE_FIELD_ORDER) {
+    record[field] = { present: 0, applicable: 0, percent: 100 };
+  }
+  return record;
+}
+function accumulateCoverage(target, item, classifier) {
+  for (const field of COVERAGE_FIELD_ORDER) {
+    if (!isFieldApplicable(item, field, classifier)) {
+      continue;
+    }
+    const entry = target[field];
+    entry.applicable += 1;
+    if (isFieldPresent(item, field)) {
+      entry.present += 1;
+    }
+  }
+}
+function finalizePercentages(record) {
+  for (const field of COVERAGE_FIELD_ORDER) {
+    const entry = record[field];
+    entry.percent = roundPercent(entry.present, entry.applicable);
+  }
+}
+function computeMetadataCoverage(items, classifier) {
+  const overall = emptyFieldCoverage();
+  const byType = {};
+  for (const item of items) {
+    accumulateCoverage(overall, item, classifier);
+    const typeRecord = byType[item.type] ?? (byType[item.type] = emptyFieldCoverage());
+    accumulateCoverage(typeRecord, item, classifier);
+  }
+  finalizePercentages(overall);
+  for (const typeRecord of Object.values(byType)) {
+    finalizePercentages(typeRecord);
+  }
+  return { overall, by_type: byType };
+}
+var EMPTY_GROUP_LABELS = {
+  assignee: "(unassigned)",
+  priority: "(no priority)",
+  tag: "(untagged)",
+  parent: "(unparented)",
+  type: "(untyped)",
+  status: "(no status)"
+};
+function emptyGroupLabel(dimension) {
+  return EMPTY_GROUP_LABELS[dimension];
+}
+function emptyBuckets() {
+  return {
+    open: 0,
+    in_progress: 0,
+    blocked: 0,
+    draft: 0,
+    closed: 0,
+    canceled: 0,
+    other: 0
+  };
+}
+function groupKeysForItem(item, dimension, options) {
+  switch (dimension) {
+    case "assignee":
+      return [toNonEmptyStringOrUndefined(item.assignee) ?? null];
+    case "parent":
+      return [toNonEmptyStringOrUndefined(item.parent) ?? null];
+    case "type":
+      return [toNonEmptyStringOrUndefined(item.type) ?? null];
+    case "status":
+      return [toNonEmptyStringOrUndefined(item.status) ?? null];
+    case "priority":
+      return [typeof item.priority === "number" ? `P${item.priority}` : null];
+    default: {
+      const prefix = options.tagPrefix?.trim();
+      const tags = Array.isArray(item.tags) ? item.tags : [];
+      const matching = tags.filter((tag) => typeof tag === "string" && tag.length > 0 && (!prefix || tag.startsWith(prefix)));
+      return matching.length > 0 ? matching : [null];
+    }
+  }
+}
+function groupItemsByDimension(items, dimension, classifier, options = {}) {
+  const rows = /* @__PURE__ */ new Map();
+  let totalItems = 0;
+  for (const item of items) {
+    totalItems += 1;
+    const bucket = classifier.classify(item.status);
+    for (const key of groupKeysForItem(item, dimension, options)) {
+      const mapKey = key ?? "\0empty";
+      let row = rows.get(mapKey);
+      if (!row) {
+        row = {
+          label: key ?? emptyGroupLabel(dimension),
+          key,
+          buckets: emptyBuckets(),
+          total: 0
+        };
+        rows.set(mapKey, row);
+      }
+      row.buckets[bucket] += 1;
+      row.total += 1;
+    }
+  }
+  const sorted = [...rows.values()].sort((left, right) => {
+    if (right.total !== left.total) {
+      return right.total - left.total;
+    }
+    if (left.key === null) {
+      return 1;
+    }
+    if (right.key === null) {
+      return -1;
+    }
+    return left.label.localeCompare(right.label);
+  });
+  return { dimension, rows: sorted, total_items: totalItems };
+}
+
+// dist/core/governance/content-fields.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9104a56e-e446-53c0-83fe-fcf651a45a49");
+  } catch (e2) {
+  }
+})();
+var CONTENT_FIELD_ORDER = [
+  "notes",
+  "learnings",
+  "files",
+  "docs",
+  "tests",
+  "comments",
+  "deps",
+  "body",
+  "linked_command"
+];
+function hasEntries(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+function hasBody(body) {
+  return typeof body === "string" && body.trim().length > 0;
+}
+function hasLinkedCommand(tests) {
+  if (!Array.isArray(tests)) {
+    return false;
+  }
+  return tests.some((entry) => {
+    if (typeof entry !== "object" || entry === null) {
+      return false;
+    }
+    const command = entry.command;
+    return typeof command === "string" && command.trim().length > 0;
+  });
+}
+function isContentFieldPresent(item, field) {
+  switch (field) {
+    case "notes":
+      return hasEntries(item.notes);
+    case "learnings":
+      return hasEntries(item.learnings);
+    case "files":
+      return hasEntries(item.files);
+    case "docs":
+      return hasEntries(item.docs);
+    case "tests":
+      return hasEntries(item.tests);
+    case "comments":
+      return hasEntries(item.comments);
+    case "deps":
+      return hasEntries(item.dependencies);
+    case "body":
+      return hasBody(item.body);
+    case "linked_command":
+      return hasLinkedCommand(item.tests);
+  }
+}
+function hasContentFieldFilter(filters) {
+  return CONTENT_FIELD_ORDER.some((field) => filters[field] !== void 0);
+}
+function itemMatchesContentFilters(item, filters) {
+  for (const field of CONTENT_FIELD_ORDER) {
+    const selection = filters[field];
+    if (selection === void 0) {
+      continue;
+    }
+    const present = isContentFieldPresent(item, field);
+    if (selection === "present" && !present) {
+      return false;
+    }
+    if (selection === "absent" && present) {
+      return false;
+    }
+  }
+  return true;
+}
+function contentFiltersNeedCollections(filters) {
+  return CONTENT_FIELD_ORDER.some((field) => field !== "body" && filters[field] !== void 0);
+}
+function contentFiltersNeedBody(filters) {
+  return filters.body !== void 0;
+}
+function roundPercent2(present, total) {
+  if (total === 0) {
+    return 100;
+  }
+  return Math.round(present / total * 1e3) / 10;
+}
+function emptyUtilizationFields() {
+  const record = {};
+  for (const field of CONTENT_FIELD_ORDER) {
+    record[field] = { present: 0, total: 0, percent: 100 };
+  }
+  return record;
+}
+function computeContentFieldUtilization(items) {
+  const fields = emptyUtilizationFields();
+  const total = items.length;
+  for (const item of items) {
+    for (const field of CONTENT_FIELD_ORDER) {
+      if (isContentFieldPresent(item, field)) {
+        fields[field].present += 1;
+      }
+    }
+  }
+  for (const field of CONTENT_FIELD_ORDER) {
+    fields[field].total = total;
+    fields[field].percent = roundPercent2(fields[field].present, total);
+  }
+  const bodyPopulated = fields.body;
+  const emptyBodyCount = total - bodyPopulated.present;
+  const emptyBody = {
+    present: emptyBodyCount,
+    total,
+    percent: roundPercent2(emptyBodyCount, total)
+  };
+  return {
+    total_items: total,
+    fields,
+    body_populated: bodyPopulated,
+    empty_body: emptyBody
+  };
+}
+
+export {
+  lifecycleClassifierFromStatusRegistry,
+  hasMissingMetadataFilter,
+  itemMatchesMissingMetadata,
+  computeMetadataCoverage,
+  groupItemsByDimension,
+  hasContentFieldFilter,
+  itemMatchesContentFilters,
+  contentFiltersNeedCollections,
+  contentFiltersNeedBody,
+  computeContentFieldUtilization
+};
+//# sourceMappingURL=chunk-7EILPFMA.js.map

package/dist/cli-bundle/chunks/chunk-7EILPFMA.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../core/governance/metadata-coverage.ts", "../../../../../../../../core/governance/content-fields.ts"],
+  "sourcesContent": ["/**\n * Metadata governance & coverage observability primitives.\n *\n * One dependency-light module that powers the whole metadata-governance\n * surface: missing-field selection (pm list / pm update-many), coverage\n * percentages (pm stats --metadata-coverage / pm validate), and grouped\n * lifecycle breakdowns (pm stats --by-assignee/--by-tag/--by-priority,\n * pm aggregate explicit labels).\n *\n * The module is pure: it performs no IO and imports no heavy runtime\n * dependencies. Lifecycle semantics are injected via a {@link LifecycleClassifier}\n * so callers map their runtime status registry to lifecycle buckets while the\n * pure logic here stays trivially testable with a fake classifier.\n */\n\nimport { toNonEmptyStringOrUndefined } from \"../shared/primitives.js\";\n\n/** Minimal structural shape this module needs from an item's front matter. */\nexport interface CoverageItem {\n  type: string;\n  status: string;\n  assignee?: string;\n  tags?: string[];\n  parent?: string;\n  priority?: number;\n  acceptance_criteria?: string;\n  estimated_minutes?: number;\n  resolution?: string;\n  reviewer?: string;\n  risk?: string;\n  /** Confidence is a string-like enum or a numeric score depending on workspace. */\n  confidence?: string | number;\n  sprint?: string;\n  release?: string;\n  [key: string]: unknown;\n}\n\n/** Lifecycle buckets used by grouped breakdowns and distributions. */\nexport type LifecycleBucket =\n  | \"open\"\n  | \"in_progress\"\n  | \"blocked\"\n  | \"draft\"\n  | \"closed\"\n  | \"canceled\"\n  | \"other\";\n\n/** Stable rendering order for lifecycle buckets. */\nexport const LIFECYCLE_BUCKET_ORDER: readonly LifecycleBucket[] = [\n  \"open\",\n  \"in_progress\",\n  \"blocked\",\n  \"draft\",\n  \"closed\",\n  \"canceled\",\n  \"other\",\n] as const;\n\n/**\n * Classifies a raw status string into a lifecycle bucket and reports whether a\n * status is terminal (closed/canceled). Callers build this from their resolved\n * runtime status registry via {@link lifecycleClassifierFromStatusRegistry}.\n */\nexport interface LifecycleClassifier {\n  classify(status: string): LifecycleBucket;\n  isTerminal(status: string): boolean;\n}\n\n/** The subset of a resolved runtime status registry this module consumes. */\nexport interface StatusRegistryLike {\n  alias_to_id: Map<string, string>;\n  terminal_statuses: Set<string>;\n  terminal_canceled_statuses: Set<string>;\n  blocked_statuses: Set<string>;\n  draft_statuses: Set<string>;\n  active_statuses: Set<string>;\n  open_status: string;\n}\n\nfunction normalizeStatus(status: string, registry: StatusRegistryLike): string {\n  const trimmed = status.trim().toLowerCase();\n  return registry.alias_to_id.get(trimmed) ?? trimmed;\n}\n\n/**\n * Adapt a resolved runtime status registry into a {@link LifecycleClassifier}.\n *\n * Precedence is deliberate and disjoint: canceled → closed → blocked → draft →\n * open → in_progress (active but not the default open status) → other.\n */\nexport function lifecycleClassifierFromStatusRegistry(registry: StatusRegistryLike): LifecycleClassifier {\n  return {\n    isTerminal(status: string): boolean {\n      return registry.terminal_statuses.has(normalizeStatus(status, registry));\n    },\n    classify(status: string): LifecycleBucket {\n      const id = normalizeStatus(status, registry);\n      if (registry.terminal_canceled_statuses.has(id)) {\n        return \"canceled\";\n      }\n      if (registry.terminal_statuses.has(id)) {\n        return \"closed\";\n      }\n      if (registry.blocked_statuses.has(id)) {\n        return \"blocked\";\n      }\n      if (registry.draft_statuses.has(id)) {\n        return \"draft\";\n      }\n      if (id === registry.open_status) {\n        return \"open\";\n      }\n      if (registry.active_statuses.has(id)) {\n        return \"in_progress\";\n      }\n      return \"other\";\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Missing-metadata predicates\n// ---------------------------------------------------------------------------\n\n/** True when an item has no non-empty acceptance_criteria. */\nexport function isAcMissing(item: CoverageItem): boolean {\n  return toNonEmptyStringOrUndefined(item.acceptance_criteria) === undefined;\n}\n\n/** True when an item has no finite estimated_minutes. */\nexport function isEstimateMissing(item: CoverageItem): boolean {\n  return !Number.isFinite(item.estimated_minutes);\n}\n\n/**\n * True when a terminal (closed/canceled) item has no non-empty resolution.\n * Resolution is only expected on terminal items, so open items are never\n * considered \"resolution-missing\".\n */\nexport function isResolutionMissing(item: CoverageItem, classifier: LifecycleClassifier): boolean {\n  if (!classifier.isTerminal(item.status)) {\n    return false;\n  }\n  return toNonEmptyStringOrUndefined(item.resolution) === undefined;\n}\n\n/** True when an item has no non-empty reviewer. */\nexport function isReviewerMissing(item: CoverageItem): boolean {\n  return toNonEmptyStringOrUndefined(item.reviewer) === undefined;\n}\n\n/** True when an item has no non-empty risk level. */\nexport function isRiskMissing(item: CoverageItem): boolean {\n  return toNonEmptyStringOrUndefined(item.risk) === undefined;\n}\n\n/**\n * True when an item has no confidence value. Confidence is a string-like enum\n * or a numeric score depending on workspace, so a finite number counts as\n * present and only blank/absent values are treated as missing.\n */\nexport function isConfidenceMissing(item: CoverageItem): boolean {\n  if (typeof item.confidence === \"number\") {\n    return !Number.isFinite(item.confidence);\n  }\n  return toNonEmptyStringOrUndefined(item.confidence) === undefined;\n}\n\n/** True when an item has no non-empty sprint. */\nexport function isSprintMissing(item: CoverageItem): boolean {\n  return toNonEmptyStringOrUndefined(item.sprint) === undefined;\n}\n\n/** True when an item has no non-empty release. */\nexport function isReleaseMissing(item: CoverageItem): boolean {\n  return toNonEmptyStringOrUndefined(item.release) === undefined;\n}\n\n/** Selection flags for {@link filterMissingMetadata}. */\nexport interface MissingMetadataFilters {\n  acMissing?: boolean;\n  estimatesMissing?: boolean;\n  resolutionMissing?: boolean;\n  reviewerMissing?: boolean;\n  riskMissing?: boolean;\n  confidenceMissing?: boolean;\n  sprintMissing?: boolean;\n  releaseMissing?: boolean;\n  /** Match items missing ANY of the tracked metadata fields (union). */\n  metadataMissing?: boolean;\n}\n\n/** True when any missing-metadata filter is requested. */\nexport function hasMissingMetadataFilter(filters: MissingMetadataFilters): boolean {\n  return Boolean(\n    filters.acMissing ||\n      filters.estimatesMissing ||\n      filters.resolutionMissing ||\n      filters.reviewerMissing ||\n      filters.riskMissing ||\n      filters.confidenceMissing ||\n      filters.sprintMissing ||\n      filters.releaseMissing ||\n      filters.metadataMissing,\n  );\n}\n\n/**\n * Does a single item satisfy the requested missing-metadata filters?\n *\n * Specific flags (acMissing/estimatesMissing/resolutionMissing plus the\n * governance flags reviewerMissing/riskMissing/confidenceMissing/sprintMissing/\n * releaseMissing) are ANDed together so callers can narrow precisely.\n * `metadataMissing` is ORed in as a union shortcut for \"missing any of the\n * core tracked fields\" (acceptance_criteria/estimated_minutes/resolution); it\n * deliberately excludes the governance fields so the long-standing flag keeps\n * its original meaning. When no filter is requested the item passes.\n */\nexport function itemMatchesMissingMetadata(\n  item: CoverageItem,\n  filters: MissingMetadataFilters,\n  classifier: LifecycleClassifier,\n): boolean {\n  if (!hasMissingMetadataFilter(filters)) {\n    return true;\n  }\n  if (filters.acMissing && !isAcMissing(item)) {\n    return false;\n  }\n  if (filters.estimatesMissing && !isEstimateMissing(item)) {\n    return false;\n  }\n  if (filters.resolutionMissing && !isResolutionMissing(item, classifier)) {\n    return false;\n  }\n  if (filters.reviewerMissing && !isReviewerMissing(item)) {\n    return false;\n  }\n  if (filters.riskMissing && !isRiskMissing(item)) {\n    return false;\n  }\n  if (filters.confidenceMissing && !isConfidenceMissing(item)) {\n    return false;\n  }\n  if (filters.sprintMissing && !isSprintMissing(item)) {\n    return false;\n  }\n  if (filters.releaseMissing && !isReleaseMissing(item)) {\n    return false;\n  }\n  if (filters.metadataMissing) {\n    const anyMissing =\n      isAcMissing(item) || isEstimateMissing(item) || isResolutionMissing(item, classifier);\n    if (!anyMissing) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Filter a list of items by the requested missing-metadata predicates. */\nexport function filterMissingMetadata<T extends CoverageItem>(\n  items: readonly T[],\n  filters: MissingMetadataFilters,\n  classifier: LifecycleClassifier,\n): T[] {\n  if (!hasMissingMetadataFilter(filters)) {\n    return [...items];\n  }\n  return items.filter((item) => itemMatchesMissingMetadata(item, filters, classifier));\n}\n\n// ---------------------------------------------------------------------------\n// Metadata coverage percentages\n// ---------------------------------------------------------------------------\n\n/** Coverage-tracked metadata fields. */\nexport type CoverageField =\n  | \"acceptance_criteria\"\n  | \"estimated_minutes\"\n  | \"resolution\"\n  | \"tags\"\n  | \"parent\";\n\n/** Stable ordering of coverage fields for rendering. */\nexport const COVERAGE_FIELD_ORDER: readonly CoverageField[] = [\n  \"acceptance_criteria\",\n  \"estimated_minutes\",\n  \"resolution\",\n  \"tags\",\n  \"parent\",\n] as const;\n\n/** Coverage of a single field: present vs applicable, with a rounded percent. */\nexport interface FieldCoverage {\n  present: number;\n  /** Items for which the field is expected (all items, except resolution = terminal only). */\n  applicable: number;\n  /** present/applicable * 100, rounded to one decimal; 100 when applicable is 0. */\n  percent: number;\n}\n\nexport interface MetadataCoverageReport {\n  overall: Record<CoverageField, FieldCoverage>;\n  by_type: Record<string, Record<CoverageField, FieldCoverage>>;\n}\n\nfunction isFieldPresent(item: CoverageItem, field: CoverageField): boolean {\n  switch (field) {\n    case \"acceptance_criteria\":\n      return !isAcMissing(item);\n    case \"estimated_minutes\":\n      return !isEstimateMissing(item);\n    case \"resolution\":\n      return toNonEmptyStringOrUndefined(item.resolution) !== undefined;\n    case \"tags\":\n      return Array.isArray(item.tags) && item.tags.length > 0;\n    default:\n      return toNonEmptyStringOrUndefined(item.parent) !== undefined;\n  }\n}\n\n/** Whether a field applies to a given item (resolution only applies to terminal items). */\nfunction isFieldApplicable(item: CoverageItem, field: CoverageField, classifier: LifecycleClassifier): boolean {\n  if (field === \"resolution\") {\n    return classifier.isTerminal(item.status);\n  }\n  return true;\n}\n\nfunction roundPercent(present: number, applicable: number): number {\n  if (applicable === 0) {\n    return 100;\n  }\n  return Math.round((present / applicable) * 1000) / 10;\n}\n\nfunction emptyFieldCoverage(): Record<CoverageField, FieldCoverage> {\n  const record = {} as Record<CoverageField, FieldCoverage>;\n  for (const field of COVERAGE_FIELD_ORDER) {\n    record[field] = { present: 0, applicable: 0, percent: 100 };\n  }\n  return record;\n}\n\nfunction accumulateCoverage(\n  target: Record<CoverageField, FieldCoverage>,\n  item: CoverageItem,\n  classifier: LifecycleClassifier,\n): void {\n  for (const field of COVERAGE_FIELD_ORDER) {\n    if (!isFieldApplicable(item, field, classifier)) {\n      continue;\n    }\n    const entry = target[field];\n    entry.applicable += 1;\n    if (isFieldPresent(item, field)) {\n      entry.present += 1;\n    }\n  }\n}\n\nfunction finalizePercentages(record: Record<CoverageField, FieldCoverage>): void {\n  for (const field of COVERAGE_FIELD_ORDER) {\n    const entry = record[field];\n    entry.percent = roundPercent(entry.present, entry.applicable);\n  }\n}\n\n/**\n * Compute metadata coverage overall and per item type. For each tracked field\n * we report present/applicable counts and a rounded percentage. Resolution is\n * scoped to terminal items (its only applicable population).\n */\nexport function computeMetadataCoverage(\n  items: readonly CoverageItem[],\n  classifier: LifecycleClassifier,\n): MetadataCoverageReport {\n  const overall = emptyFieldCoverage();\n  const byType: Record<string, Record<CoverageField, FieldCoverage>> = {};\n  for (const item of items) {\n    accumulateCoverage(overall, item, classifier);\n    const typeRecord = byType[item.type] ?? (byType[item.type] = emptyFieldCoverage());\n    accumulateCoverage(typeRecord, item, classifier);\n  }\n  finalizePercentages(overall);\n  for (const typeRecord of Object.values(byType)) {\n    finalizePercentages(typeRecord);\n  }\n  return { overall, by_type: byType };\n}\n\n// ---------------------------------------------------------------------------\n// Grouped lifecycle breakdowns\n// ---------------------------------------------------------------------------\n\n/** Dimensions a breakdown can group by. */\nexport type GroupDimension = \"assignee\" | \"priority\" | \"tag\" | \"parent\" | \"type\" | \"status\";\n\n/** Explicit labels for empty/blank group keys, by dimension. */\nconst EMPTY_GROUP_LABELS: Record<GroupDimension, string> = {\n  assignee: \"(unassigned)\",\n  priority: \"(no priority)\",\n  tag: \"(untagged)\",\n  parent: \"(unparented)\",\n  type: \"(untyped)\",\n  status: \"(no status)\",\n};\n\n/** Explicit label for an empty/blank group value for a given dimension. */\nexport function emptyGroupLabel(dimension: GroupDimension): string {\n  return EMPTY_GROUP_LABELS[dimension];\n}\n\nexport interface GroupRow {\n  /** Display label; explicit \"(unassigned)\"-style label for blank keys. */\n  label: string;\n  /** Stable structured key (null for the empty/blank group). */\n  key: string | null;\n  buckets: Record<LifecycleBucket, number>;\n  total: number;\n}\n\nexport interface GroupedBreakdown {\n  dimension: GroupDimension;\n  rows: GroupRow[];\n  /** Distinct items observed (an item can contribute to multiple tag rows). */\n  total_items: number;\n}\n\nexport interface GroupOptions {\n  /** For dimension=\"tag\": only consider tags starting with this prefix. */\n  tagPrefix?: string;\n}\n\nfunction emptyBuckets(): Record<LifecycleBucket, number> {\n  return {\n    open: 0,\n    in_progress: 0,\n    blocked: 0,\n    draft: 0,\n    closed: 0,\n    canceled: 0,\n    other: 0,\n  };\n}\n\n/**\n * Resolve the group keys an item belongs to for a dimension. Most dimensions\n * yield exactly one key (possibly null for blank); tag yields one key per\n * matching tag (or [null] when none match), so an item can span multiple rows.\n */\nfunction groupKeysForItem(item: CoverageItem, dimension: GroupDimension, options: GroupOptions): (string | null)[] {\n  switch (dimension) {\n    case \"assignee\":\n      return [toNonEmptyStringOrUndefined(item.assignee) ?? null];\n    case \"parent\":\n      return [toNonEmptyStringOrUndefined(item.parent) ?? null];\n    case \"type\":\n      return [toNonEmptyStringOrUndefined(item.type) ?? null];\n    case \"status\":\n      return [toNonEmptyStringOrUndefined(item.status) ?? null];\n    case \"priority\":\n      return [typeof item.priority === \"number\" ? `P${item.priority}` : null];\n    default: {\n      const prefix = options.tagPrefix?.trim();\n      const tags = Array.isArray(item.tags) ? item.tags : [];\n      const matching = tags.filter(\n        (tag) => typeof tag === \"string\" && tag.length > 0 && (!prefix || tag.startsWith(prefix)),\n      );\n      return matching.length > 0 ? matching : [null];\n    }\n  }\n}\n\n/**\n * Group items by a dimension into lifecycle-bucketed rows. Blank keys render\n * with an explicit \"(unassigned)\"-style label. Rows are sorted by total\n * descending, then label ascending, with the empty group sorted last on ties.\n */\nexport function groupItemsByDimension(\n  items: readonly CoverageItem[],\n  dimension: GroupDimension,\n  classifier: LifecycleClassifier,\n  options: GroupOptions = {},\n): GroupedBreakdown {\n  const rows = new Map<string, GroupRow>();\n  let totalItems = 0;\n  for (const item of items) {\n    totalItems += 1;\n    const bucket = classifier.classify(item.status);\n    for (const key of groupKeysForItem(item, dimension, options)) {\n      const mapKey = key ?? \"\u0000empty\";\n      let row = rows.get(mapKey);\n      if (!row) {\n        row = {\n          label: key ?? emptyGroupLabel(dimension),\n          key,\n          buckets: emptyBuckets(),\n          total: 0,\n        };\n        rows.set(mapKey, row);\n      }\n      row.buckets[bucket] += 1;\n      row.total += 1;\n    }\n  }\n  const sorted = [...rows.values()].sort((left, right) => {\n    if (right.total !== left.total) {\n      return right.total - left.total;\n    }\n    // All blank-key items collapse into a single row per dimension, so at most\n    // one row has key === null; it sorts last on ties.\n    if (left.key === null) {\n      return 1;\n    }\n    if (right.key === null) {\n      return -1;\n    }\n    return left.label.localeCompare(right.label);\n  });\n  return { dimension, rows: sorted, total_items: totalItems };\n}\n\n/** Lifecycle-bucket distribution across all items (for stats lifecycle section). */\nexport function computeLifecycleDistribution(\n  items: readonly CoverageItem[],\n  classifier: LifecycleClassifier,\n): Record<LifecycleBucket, number> {\n  const buckets = emptyBuckets();\n  for (const item of items) {\n    buckets[classifier.classify(item.status)] += 1;\n  }\n  return buckets;\n}\n", "/**\n * Content-field governance & utilization primitives.\n *\n * \"Project management = context management\": these primitives let agents query\n * which items carry context (notes/learnings/files/docs/tests/comments/deps/\n * body, plus whether a linked test carries a runnable command) and which do\n * not. The surface powers content-field selection (pm list / pm update-many)\n * and field-utilization reporting (pm stats --field-utilization).\n *\n * The module is pure: it performs no IO and imports no heavy runtime\n * dependencies. Callers pass plain structural item shapes so the logic stays\n * trivially testable.\n */\n\n/** The content fields an item can carry context in. */\nexport type ContentField =\n  | \"notes\"\n  | \"learnings\"\n  | \"files\"\n  | \"docs\"\n  | \"tests\"\n  | \"comments\"\n  | \"deps\"\n  | \"body\"\n  | \"linked_command\";\n\n/** Stable rendering / iteration order for content fields. */\nexport const CONTENT_FIELD_ORDER: readonly ContentField[] = [\n  \"notes\",\n  \"learnings\",\n  \"files\",\n  \"docs\",\n  \"tests\",\n  \"comments\",\n  \"deps\",\n  \"body\",\n  \"linked_command\",\n] as const;\n\n/** Minimal structural shape needed: the collection arrays + optional body. */\nexport interface ContentFieldItem {\n  notes?: unknown[];\n  learnings?: unknown[];\n  files?: unknown[];\n  docs?: unknown[];\n  tests?: unknown[];\n  comments?: unknown[];\n  dependencies?: unknown[];\n  body?: string;\n  [key: string]: unknown;\n}\n\n/** True when `value` is a non-empty array. */\nfunction hasEntries(value: unknown): boolean {\n  return Array.isArray(value) && value.length > 0;\n}\n\n/** True when the body string carries non-whitespace content. */\nfunction hasBody(body: unknown): boolean {\n  return typeof body === \"string\" && body.trim().length > 0;\n}\n\n/**\n * True when at least one entry in the `tests` array carries a non-empty string\n * `command`. Tolerant of non-object / non-string entries.\n */\nfunction hasLinkedCommand(tests: unknown): boolean {\n  if (!Array.isArray(tests)) {\n    return false;\n  }\n  return tests.some((entry) => {\n    if (typeof entry !== \"object\" || entry === null) {\n      return false;\n    }\n    const command = (entry as { command?: unknown }).command;\n    return typeof command === \"string\" && command.trim().length > 0;\n  });\n}\n\n/**\n * True when the given content field carries context on this item.\n * - collection fields: `Array.isArray && length > 0`\n * - \"deps\": maps to the `dependencies` array\n * - \"body\": `typeof body === \"string\" && body.trim().length > 0`\n * - \"linked_command\": `tests` array has at least one entry with a non-empty\n *   string `command`\n */\nexport function isContentFieldPresent(item: ContentFieldItem, field: ContentField): boolean {\n  switch (field) {\n    case \"notes\":\n      return hasEntries(item.notes);\n    case \"learnings\":\n      return hasEntries(item.learnings);\n    case \"files\":\n      return hasEntries(item.files);\n    case \"docs\":\n      return hasEntries(item.docs);\n    case \"tests\":\n      return hasEntries(item.tests);\n    case \"comments\":\n      return hasEntries(item.comments);\n    case \"deps\":\n      return hasEntries(item.dependencies);\n    case \"body\":\n      return hasBody(item.body);\n    case \"linked_command\":\n      return hasLinkedCommand(item.tests);\n  }\n  // No default: every ContentField has an explicit case above, so TypeScript\n  // enforces exhaustiveness here — adding a new field without a case is a\n  // compile error rather than a silent fall-through (and no unreachable branch\n  // to dent the literal-100% coverage gate).\n}\n\n/** Per-field selection: 'present' requires the field populated, 'absent' requires it empty. */\nexport type ContentFieldSelection = \"present\" | \"absent\";\n\n/** Map of content fields to a present/absent requirement. */\nexport type ContentFieldFilters = Partial<Record<ContentField, ContentFieldSelection>>;\n\n/** True when at least one content-field selection is requested. */\nexport function hasContentFieldFilter(filters: ContentFieldFilters): boolean {\n  return CONTENT_FIELD_ORDER.some((field) => filters[field] !== undefined);\n}\n\n/**\n * Does a single item satisfy the requested content-field filters?\n *\n * AND semantics across all requested fields: each requested field must match\n * its present/absent requirement. When no filter is requested the item passes.\n */\nexport function itemMatchesContentFilters(item: ContentFieldItem, filters: ContentFieldFilters): boolean {\n  for (const field of CONTENT_FIELD_ORDER) {\n    const selection = filters[field];\n    if (selection === undefined) {\n      continue;\n    }\n    const present = isContentFieldPresent(item, field);\n    if (selection === \"present\" && !present) {\n      return false;\n    }\n    if (selection === \"absent\" && present) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Filter a list of items by the requested content-field selections. */\nexport function filterByContentFields<T extends ContentFieldItem>(\n  items: readonly T[],\n  filters: ContentFieldFilters,\n): T[] {\n  if (!hasContentFieldFilter(filters)) {\n    return [...items];\n  }\n  return items.filter((item) => itemMatchesContentFilters(item, filters));\n}\n\n/**\n * Whether a content-field filter set requires the heavy collections to be\n * loaded. True when any non-body field is requested (collections + tests'\n * linked command all live in the heavy front-matter arrays).\n */\nexport function contentFiltersNeedCollections(filters: ContentFieldFilters): boolean {\n  return CONTENT_FIELD_ORDER.some((field) => field !== \"body\" && filters[field] !== undefined);\n}\n\n/** Whether a content-field filter set requires the item body to be loaded. */\nexport function contentFiltersNeedBody(filters: ContentFieldFilters): boolean {\n  return filters.body !== undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Field utilization\n// ---------------------------------------------------------------------------\n\n/** Utilization of a single content field: present vs total, with a rounded percent. */\nexport interface ContentFieldUtilization {\n  present: number;\n  total: number;\n  /** present/total * 100, rounded to one decimal; 100 when total is 0. */\n  percent: number;\n}\n\n/** Per-field utilization report for pm stats --field-utilization. */\nexport interface ContentFieldUtilizationReport {\n  total_items: number;\n  /** Utilization keyed by content field (includes body and linked_command). */\n  fields: Record<ContentField, ContentFieldUtilization>;\n  /** Convenience alias mirroring GH-241: identical to `fields.body`. */\n  body_populated: ContentFieldUtilization;\n  /** Items with an empty body; `present` counts the empty-bodied items. */\n  empty_body: ContentFieldUtilization;\n}\n\n/**\n * Round present/total into a one-decimal percentage. Matches the convention in\n * metadata-coverage.ts: a zero population reports 100 (nothing missing).\n */\nfunction roundPercent(present: number, total: number): number {\n  if (total === 0) {\n    return 100;\n  }\n  return Math.round((present / total) * 1000) / 10;\n}\n\nfunction emptyUtilizationFields(): Record<ContentField, ContentFieldUtilization> {\n  const record = {} as Record<ContentField, ContentFieldUtilization>;\n  for (const field of CONTENT_FIELD_ORDER) {\n    record[field] = { present: 0, total: 0, percent: 100 };\n  }\n  return record;\n}\n\n/**\n * Compute content-field utilization across a list of items. For each field we\n * report how many items populate it out of the total, plus a rounded\n * percentage. Convenience `body_populated`/`empty_body` aliases mirror GH-241.\n */\nexport function computeContentFieldUtilization(\n  items: readonly ContentFieldItem[],\n): ContentFieldUtilizationReport {\n  const fields = emptyUtilizationFields();\n  const total = items.length;\n  for (const item of items) {\n    for (const field of CONTENT_FIELD_ORDER) {\n      if (isContentFieldPresent(item, field)) {\n        fields[field].present += 1;\n      }\n    }\n  }\n  for (const field of CONTENT_FIELD_ORDER) {\n    fields[field].total = total;\n    fields[field].percent = roundPercent(fields[field].present, total);\n  }\n  const bodyPopulated = fields.body;\n  const emptyBodyCount = total - bodyPopulated.present;\n  const emptyBody: ContentFieldUtilization = {\n    present: emptyBodyCount,\n    total,\n    percent: roundPercent(emptyBodyCount, total),\n  };\n  return {\n    total_items: total,\n    fields,\n    body_populated: bodyPopulated,\n    empty_body: emptyBody,\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["roundPercent"]
+}

package/dist/cli-bundle/chunks/{chunk-L6YQONLM.js → chunk-7K2MXFMX.js}

@@ -1,20 +1,20 @@
 
-!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]="46c683b0-8c69-530c-9011-0969f6a182bb")}catch(e){}}();
+!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]="6298c042-389f-5171-8b21-c8987ccdb764")}catch(e){}}();
 import {
   normalizeItemId,
   normalizeRawItemId
-} from "./chunk-6ZFTM65G.js";
+} from "./chunk-2JEGCDYT.js";
 import {
   canonicalDocument,
   parseItemDocument,
   serializeItemDocument
-} from "./chunk-QQG4HEX7.js";
+} from "./chunk-GAVE4MYM.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-32XSW44C.js";
+} from "./chunk-ZONXMSVB.js";
 import {
   nowIso
-} from "./chunk-IZHCCG4S.js";
+} from "./chunk-G2YVUY7I.js";
 import {
   EMPTY_CANONICAL_DOCUMENT,
   EXIT_CODE,
@@ -44,7 +44,7 @@ import {
   stableStringify,
   toErrorMessage,
   writeFileAtomic
-} from "./chunk-S2CDTRJ6.js";
+} from "./chunk-KTVETP66.js";
 
 // dist/core/extensions/item-fields.js
 var RESERVED_ITEM_FIELD_NAMES = new Set(FRONT_MATTER_KEY_ORDER);
@@ -76,9 +76,6 @@ function parseFieldAssignment(raw) {
   }
   const key = trimmed.slice(0, separatorIndex).trim();
   const value = trimmed.slice(separatorIndex + 1);
-  if (key.length === 0) {
-    throw new PmCliError("--field entries require a non-empty field name", EXIT_CODE.USAGE);
-  }
   return { key, value };
 }
 function parseJsonFieldValue(raw, fieldName, expectedType) {
@@ -964,7 +961,8 @@ async function listAllFrontMatterWithBody(pmRoot, preferredFormat, typeToFolder
   const candidates = await listAllDocumentCandidatesCached(pmRoot, preferredFormat, typeToFolder, warnings, schema, { includeBody: true });
   return candidates.map((candidate) => ({
     ...candidate.metadata,
-    body: candidate.body ?? ""
+    // includeBody:true guarantees candidate bodies are materialized.
+    body: candidate.body
   }));
 }
 async function listKnownItemIds(pmRoot, typeToFolder) {
@@ -1004,7 +1002,7 @@ async function buildItemNotFoundError(pmRoot, badId, idPrefix, typeToFolder) {
   return new PmCliError(`Item ${badId} not found`, EXIT_CODE.NOT_FOUND, { nextSteps });
 }
 function bypassesAssigneeConflict(op, bypassAssigneeConflict) {
-  return op === "claim" || bypassAssigneeConflict === true && (op === "comment_add" || op === "note_add" || op === "learning_add" || op === "release" || op === "update" || op === "update_audit");
+  return op === "claim" || bypassAssigneeConflict === true && (op === "comment_add" || op === "comment_edit" || op === "comment_delete" || op === "note_add" || op === "learning_add" || op === "release" || op === "update" || op === "update_audit");
 }
 async function prepareLockedItem(params) {
   const typeToFolder = params.typeToFolder ?? resolveItemTypeRegistry(params.settings, getActiveExtensionRegistrations()).type_to_folder;
@@ -1316,6 +1314,6 @@ export {
   mutateItem,
   deleteItem
 };
-//# sourceMappingURL=chunk-L6YQONLM.js.map
+//# sourceMappingURL=chunk-7K2MXFMX.js.map
 
-//# debugId=46c683b0-8c69-530c-9011-0969f6a182bb
+//# debugId=6298c042-389f-5171-8b21-c8987ccdb764