@unbrained/pm-cli 2026.5.29 → 2026.5.31

package/dist/cli-bundle/chunks/context-RZ5QPNJB.js

@@ -0,0 +1,1458 @@
+import {
+  runActivity
+} from "./chunk-L2FXEKDB.js";
+import "./chunk-LRBOHPUE.js";
+import "./chunk-JFWUHHS2.js";
+import {
+  levenshteinDistanceWithinLimit
+} from "./chunk-EAOG77HM.js";
+import {
+  runList
+} from "./chunk-FQE6XZDB.js";
+import {
+  collectRuntimeFilterValues,
+  matchesRuntimeFilters
+} from "./chunk-FM26RGSU.js";
+import {
+  parseIntegerLimit,
+  parsePriority,
+  parseType
+} from "./chunk-SEXQN4KL.js";
+import {
+  listAllFrontMatterLight
+} from "./chunk-BUPWJ3IJ.js";
+import "./chunk-4AEZR5EJ.js";
+import "./chunk-CEFIVZPG.js";
+import {
+  isTerminalStatus,
+  normalizeStatusForRegistry,
+  normalizeStatusInput
+} from "./chunk-MD7K4JYF.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-WDPXDQFG.js";
+import {
+  compareTimestampStrings,
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-PVNQLCIS.js";
+import {
+  CONTEXT_DEPTH_VALUES,
+  CONTEXT_SECTION_VALUES,
+  EXIT_CODE,
+  PmCliError,
+  SETTINGS_DEFAULTS,
+  getActiveExtensionRegistrations,
+  getSettingsPath,
+  pathExists,
+  readSettings,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  weekdayOrderIndex
+} from "./chunk-LSXGH6NE.js";
+
+// dist/cli/commands/calendar.js
+import { encode as encodeToon } from "@toon-format/toon";
+!(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] = "da600821-1762-55a5-9cf5-0ea9f8ac1781");
+  } catch (e2) {
+  }
+})();
+var CALENDAR_VIEW_VALUES = ["agenda", "day", "week", "month"];
+var UTC_DAY_TO_WEEKDAY = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+var DEFAULT_RECURRENCE_LOOKAHEAD_DAYS = 365;
+var DEFAULT_RECURRENCE_LOOKBACK_DAYS = 365;
+var DEFAULT_EVENTS_ONLY_LOOKAHEAD_DAYS = 28;
+var MAX_RECURRENCE_OCCURRENCES = 1e3;
+function parseNonNegativeInteger(raw, label) {
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new PmCliError(`${label} must be a non-negative integer`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseIncludeSources(raw) {
+  if (!raw) {
+    return /* @__PURE__ */ new Set(["deadlines", "reminders", "events"]);
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "all") {
+    return /* @__PURE__ */ new Set(["deadlines", "reminders", "events"]);
+  }
+  const values = normalized.split(/[\|,]/).map((value) => value.trim()).filter((value) => value.length > 0);
+  if (values.length === 0) {
+    throw new PmCliError("Calendar include filter must not be empty", EXIT_CODE.USAGE);
+  }
+  const include = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    if (value === "deadlines" || value === "deadline") {
+      include.add("deadlines");
+      continue;
+    }
+    if (value === "reminders" || value === "reminder") {
+      include.add("reminders");
+      continue;
+    }
+    if (value === "events" || value === "event" || value === "scheduled") {
+      include.add("events");
+      continue;
+    }
+    throw new PmCliError("Calendar include filter must be deadlines|reminders|events|scheduled|all", EXIT_CODE.USAGE);
+  }
+  return include;
+}
+function suggestClosestChoice(value, choices) {
+  let best;
+  for (const choice of choices) {
+    const distance = levenshteinDistanceWithinLimit(value, choice, 2);
+    if (distance !== null && (best === void 0 || distance < best.distance)) {
+      best = { choice, distance };
+    }
+  }
+  return best?.choice;
+}
+function parseView(raw) {
+  if (!raw)
+    return "agenda";
+  const normalized = raw.trim().toLowerCase();
+  if (!CALENDAR_VIEW_VALUES.includes(normalized)) {
+    const suggestion = suggestClosestChoice(normalized, CALENDAR_VIEW_VALUES);
+    throw new PmCliError(`Calendar view must be one of ${CALENDAR_VIEW_VALUES.join("|")}${suggestion ? `. Did you mean "${suggestion}"?` : "."}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseStatus(raw, statusRegistry) {
+  if (raw === void 0)
+    return void 0;
+  const normalized = normalizeStatusInput(raw, statusRegistry);
+  if (!normalized) {
+    const allowedStatuses = statusRegistry.definitions.map((definition) => definition.id);
+    throw new PmCliError(`Calendar status filter must be one of ${allowedStatuses.join("|")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseAssigneeFilter(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (!normalized) {
+    throw new PmCliError("Calendar assignee filter must be one of assigned|unassigned", EXIT_CODE.USAGE);
+  }
+  if (normalized !== "assigned" && normalized !== "unassigned") {
+    throw new PmCliError(`Invalid calendar assignee filter "${raw}". Allowed: assigned|unassigned`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function toUtcDayKey(timestamp) {
+  return new Date(timestamp).toISOString().slice(0, 10);
+}
+function toLocalDayKey(timestamp, timezone) {
+  if (!timezone || timezone === "UTC") {
+    return toUtcDayKey(timestamp);
+  }
+  try {
+    const parts = new Intl.DateTimeFormat("en-CA", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).formatToParts(new Date(timestamp));
+    const year = parts.find((part) => part.type === "year")?.value;
+    const month = parts.find((part) => part.type === "month")?.value;
+    const day = parts.find((part) => part.type === "day")?.value;
+    if (year && month && day) {
+      return `${year}-${month}-${day}`;
+    }
+  } catch {
+  }
+  return toUtcDayKey(timestamp);
+}
+function startOfUtcDay(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), 0, 0, 0, 0)).toISOString();
+}
+function addUtcDays(timestamp, days) {
+  const date = new Date(timestamp);
+  return new Date(date.getTime() + days * 24 * 60 * 60 * 1e3).toISOString();
+}
+function startOfUtcWeekMonday(timestamp) {
+  const base = new Date(startOfUtcDay(timestamp));
+  const day = base.getUTCDay();
+  const delta = day === 0 ? -6 : 1 - day;
+  return addUtcDays(base.toISOString(), delta);
+}
+function startOfUtcMonth(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1, 0, 0, 0, 0)).toISOString();
+}
+function startOfNextUtcMonth(timestamp) {
+  const date = new Date(timestamp);
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1, 0, 0, 0, 0)).toISOString();
+}
+function maxTimestamp(left, right) {
+  return compareTimestampStrings(left, right) >= 0 ? left : right;
+}
+function toSortedCountRecord(values) {
+  return Object.fromEntries([...values.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function incrementCount(values, key) {
+  values.set(key, (values.get(key) ?? 0) + 1);
+}
+function formatRecurrenceRuleForSummary(rule) {
+  if (!rule) {
+    return null;
+  }
+  const parts = [`freq=${rule.freq}`];
+  if (rule.interval !== void 0) {
+    parts.push(`interval=${rule.interval}`);
+  }
+  if (rule.count !== void 0) {
+    parts.push(`count=${rule.count}`);
+  }
+  if (rule.until) {
+    parts.push(`until=${rule.until}`);
+  }
+  if (rule.by_weekday && rule.by_weekday.length > 0) {
+    const weekdays = [...rule.by_weekday].sort((left, right) => weekdayOrderIndex(left) - weekdayOrderIndex(right));
+    parts.push(`by_weekday=${weekdays.join("|")}`);
+  }
+  if (rule.by_month_day && rule.by_month_day.length > 0) {
+    const monthDays = [...rule.by_month_day].sort((left, right) => left - right);
+    parts.push(`by_month_day=${monthDays.join("|")}`);
+  }
+  if (rule.exdates && rule.exdates.length > 0) {
+    const exdates = [...rule.exdates].sort((left, right) => left.localeCompare(right));
+    parts.push(`exdates=${exdates.join("|")}`);
+  }
+  return parts.join(",");
+}
+function buildUtcTimestamp(year, month, day, timeSource) {
+  const candidate = new Date(Date.UTC(year, month, day, timeSource.getUTCHours(), timeSource.getUTCMinutes(), timeSource.getUTCSeconds(), timeSource.getUTCMilliseconds()));
+  if (candidate.getUTCFullYear() !== year || candidate.getUTCMonth() !== month || candidate.getUTCDate() !== day) {
+    return void 0;
+  }
+  return candidate.toISOString();
+}
+function weekdayToken(timestamp) {
+  return UTC_DAY_TO_WEEKDAY[new Date(timestamp).getUTCDay()];
+}
+function buildRecurringEventWindow(start, end, nowValue, lookbackDays, lookaheadDays) {
+  const windowStart = start ?? addUtcDays(nowValue, -(lookbackDays ?? DEFAULT_RECURRENCE_LOOKBACK_DAYS));
+  const windowEnd = end ?? addUtcDays(start ?? nowValue, lookaheadDays ?? DEFAULT_RECURRENCE_LOOKAHEAD_DAYS);
+  return {
+    start: windowStart,
+    end: compareTimestampStrings(windowEnd, windowStart) > 0 ? windowEnd : addUtcDays(windowStart, 1)
+  };
+}
+function expandRecurringOccurrences(startAt, recurrence, window2, occurrenceLimit) {
+  const maxOccurrences = occurrenceLimit ?? MAX_RECURRENCE_OCCURRENCES;
+  const interval = recurrence.interval ?? 1;
+  const countLimit = recurrence.count ?? Number.POSITIVE_INFINITY;
+  const until = recurrence.until;
+  const excluded = new Set(recurrence.exdates ?? []);
+  const recurrenceWeekdays = recurrence.by_weekday && recurrence.by_weekday.length > 0 ? [...recurrence.by_weekday] : [weekdayToken(startAt)];
+  const recurrenceMonthDays = recurrence.by_month_day && recurrence.by_month_day.length > 0 ? [...recurrence.by_month_day] : [new Date(startAt).getUTCDate()];
+  const weekdayFilter = recurrence.by_weekday ? new Set(recurrence.by_weekday) : void 0;
+  const monthDayFilter = recurrence.by_month_day ? new Set(recurrence.by_month_day) : void 0;
+  const sortedWeekdays = [...new Set(recurrenceWeekdays)].sort((left, right) => weekdayOrderIndex(left) - weekdayOrderIndex(right));
+  const sortedMonthDays = [...new Set(recurrenceMonthDays)].sort((left, right) => left - right);
+  const occurrences = [];
+  let produced = 0;
+  const consumeCandidate = (candidateAt) => {
+    if (compareTimestampStrings(candidateAt, startAt) < 0) {
+      return "continue";
+    }
+    if (until && compareTimestampStrings(candidateAt, until) > 0) {
+      return "stop";
+    }
+    if (compareTimestampStrings(candidateAt, window2.end) >= 0) {
+      return "stop";
+    }
+    if (excluded.has(candidateAt)) {
+      return "continue";
+    }
+    produced += 1;
+    if (compareTimestampStrings(candidateAt, window2.start) >= 0) {
+      occurrences.push(candidateAt);
+    }
+    if (produced >= countLimit) {
+      return "stop";
+    }
+    return "continue";
+  };
+  const startDate = new Date(startAt);
+  if (recurrence.freq === "daily") {
+    let candidateAt = startAt;
+    for (let iteration = 0; iteration < maxOccurrences; iteration += 1) {
+      const candidateWeekday = weekdayToken(candidateAt);
+      const candidateMonthDay = new Date(candidateAt).getUTCDate();
+      const weekdayMatches = !weekdayFilter || weekdayFilter.has(candidateWeekday);
+      const monthDayMatches = !monthDayFilter || monthDayFilter.has(candidateMonthDay);
+      if (weekdayMatches && monthDayMatches && consumeCandidate(candidateAt) === "stop") {
+        break;
+      }
+      candidateAt = addUtcDays(candidateAt, interval);
+    }
+    return occurrences;
+  }
+  if (recurrence.freq === "weekly") {
+    const weekStart = startOfUtcWeekMonday(startAt);
+    for (let step = 0; step < maxOccurrences; step += 1) {
+      const candidateWeekStart = addUtcDays(weekStart, step * interval * 7);
+      for (const weekday of sortedWeekdays) {
+        const dayOffset = weekdayOrderIndex(weekday);
+        const candidateDay = addUtcDays(candidateWeekStart, dayOffset);
+        const dayDate = new Date(candidateDay);
+        const candidateAt = new Date(Date.UTC(dayDate.getUTCFullYear(), dayDate.getUTCMonth(), dayDate.getUTCDate(), startDate.getUTCHours(), startDate.getUTCMinutes(), startDate.getUTCSeconds(), startDate.getUTCMilliseconds())).toISOString();
+        const candidateMonthDay = dayDate.getUTCDate();
+        if (monthDayFilter && !monthDayFilter.has(candidateMonthDay)) {
+          continue;
+        }
+        const consumed = consumeCandidate(candidateAt);
+        if (consumed === "stop") {
+          return occurrences;
+        }
+      }
+    }
+    return occurrences;
+  }
+  if (recurrence.freq === "monthly") {
+    const startYear = startDate.getUTCFullYear();
+    const startMonth = startDate.getUTCMonth();
+    for (let step = 0; step < maxOccurrences; step += 1) {
+      const monthAnchor = new Date(Date.UTC(startYear, startMonth + step * interval, 1, 0, 0, 0, 0));
+      const year2 = monthAnchor.getUTCFullYear();
+      const month2 = monthAnchor.getUTCMonth();
+      for (const monthDay of sortedMonthDays) {
+        const candidateAt = buildUtcTimestamp(year2, month2, monthDay, startDate);
+        if (!candidateAt) {
+          continue;
+        }
+        const candidateWeekday = weekdayToken(candidateAt);
+        if (weekdayFilter && !weekdayFilter.has(candidateWeekday)) {
+          continue;
+        }
+        const consumed = consumeCandidate(candidateAt);
+        if (consumed === "stop") {
+          return occurrences;
+        }
+      }
+    }
+    return occurrences;
+  }
+  const year = startDate.getUTCFullYear();
+  const month = startDate.getUTCMonth();
+  for (let step = 0; step < maxOccurrences; step += 1) {
+    const candidateYear = year + step * interval;
+    for (const monthDay of sortedMonthDays) {
+      const candidateAt = buildUtcTimestamp(candidateYear, month, monthDay, startDate);
+      if (!candidateAt) {
+        continue;
+      }
+      const candidateWeekday = weekdayToken(candidateAt);
+      if (weekdayFilter && !weekdayFilter.has(candidateWeekday)) {
+        continue;
+      }
+      const consumed = consumeCandidate(candidateAt);
+      if (consumed === "stop") {
+        return occurrences;
+      }
+    }
+  }
+  return occurrences;
+}
+function sortEvents(values) {
+  return [...values].sort((a, b) => {
+    const byAt = compareTimestampStrings(a.at, b.at);
+    if (byAt !== 0)
+      return byAt;
+    const byPriority = a.item_priority - b.item_priority;
+    if (byPriority !== 0)
+      return byPriority;
+    const byId = a.item_id.localeCompare(b.item_id);
+    if (byId !== 0)
+      return byId;
+    const byKind = a.kind.localeCompare(b.kind);
+    if (byKind !== 0)
+      return byKind;
+    const byEventTitle = String(a.event_title).localeCompare(String(b.event_title));
+    if (byEventTitle !== 0)
+      return byEventTitle;
+    return String(a.reminder_text).localeCompare(String(b.reminder_text));
+  });
+}
+function buildEventSeed(items, recurringWindow, includeSources, occurrenceLimit) {
+  const events = [];
+  for (const item of items) {
+    if (includeSources.has("deadlines") && item.deadline) {
+      events.push({
+        at: item.deadline,
+        date: toUtcDayKey(item.deadline),
+        kind: "deadline",
+        reminder_text: null,
+        event_title: null,
+        event_end: null,
+        event_location: null,
+        event_all_day: null,
+        event_timezone: null,
+        event_recurring: null,
+        event_recurrence_rule: null,
+        item_id: item.id,
+        item_title: item.title,
+        item_type: item.type,
+        item_status: item.status,
+        item_priority: item.priority,
+        item_assignee: item.assignee ?? null,
+        item_deadline: item.deadline,
+        item_tags: item.tags
+      });
+    }
+    for (const reminder of includeSources.has("reminders") ? item.reminders ?? [] : []) {
+      events.push({
+        at: reminder.at,
+        date: toUtcDayKey(reminder.at),
+        kind: "reminder",
+        reminder_text: reminder.text,
+        event_title: null,
+        event_end: null,
+        event_location: null,
+        event_all_day: null,
+        event_timezone: null,
+        event_recurring: null,
+        event_recurrence_rule: null,
+        item_id: item.id,
+        item_title: item.title,
+        item_type: item.type,
+        item_status: item.status,
+        item_priority: item.priority,
+        item_assignee: item.assignee ?? null,
+        item_deadline: item.deadline ?? null,
+        item_tags: item.tags
+      });
+    }
+    for (const event of includeSources.has("events") ? item.events ?? [] : []) {
+      const recurrenceRuleSummary = formatRecurrenceRuleForSummary(event.recurrence);
+      const recurringDurationMs = (() => {
+        if (!event.end_at) {
+          return null;
+        }
+        const duration = Date.parse(event.end_at) - Date.parse(event.start_at);
+        return Number.isFinite(duration) && duration > 0 ? duration : null;
+      })();
+      const occurrences = event.recurrence ? expandRecurringOccurrences(event.start_at, event.recurrence, recurringWindow, occurrenceLimit) : [event.start_at];
+      for (const occurrenceAt of occurrences) {
+        const occurrenceEnd = event.recurrence && recurringDurationMs !== null ? new Date(new Date(occurrenceAt).getTime() + recurringDurationMs).toISOString() : event.end_at ?? null;
+        events.push({
+          at: occurrenceAt,
+          // All-day events are timezone-agnostic calendar dates: bucket by the
+          // literal start date. Timed events bucket by their local day in the
+          // event's timezone (defaults to UTC when unset).
+          date: event.all_day === true ? occurrenceAt.slice(0, 10) : toLocalDayKey(occurrenceAt, event.timezone),
+          kind: "event",
+          reminder_text: event.description ?? null,
+          event_title: event.title ?? item.title,
+          event_end: occurrenceEnd,
+          event_location: event.location ?? null,
+          event_all_day: event.all_day ?? null,
+          event_timezone: event.timezone ?? null,
+          event_recurring: event.recurrence ? true : false,
+          event_recurrence_rule: recurrenceRuleSummary,
+          item_id: item.id,
+          item_title: item.title,
+          item_type: item.type,
+          item_status: item.status,
+          item_priority: item.priority,
+          item_assignee: item.assignee ?? null,
+          item_deadline: item.deadline ?? null,
+          item_tags: item.tags
+        });
+      }
+    }
+  }
+  return sortEvents(events);
+}
+function filterItems(items, options, typeRegistry, statusRegistry, runtimeFieldFilters) {
+  const typeFilter = parseType(options.type, typeRegistry);
+  const tagFilter = options.tag?.trim().toLowerCase();
+  const priorityFilter = parsePriority(options.priority);
+  const statusFilter = parseStatus(options.status, statusRegistry);
+  const assigneeFilter = options.assignee?.trim();
+  const assigneeModeFilter = parseAssigneeFilter(options.assigneeFilter);
+  const sprintFilter = options.sprint?.trim();
+  const releaseFilter = options.release?.trim();
+  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);
+  }
+  return items.filter((item) => {
+    if (typeFilter && item.type !== typeFilter)
+      return false;
+    if (tagFilter && !item.tags.some((tag) => tag.trim().toLowerCase() === tagFilter))
+      return false;
+    if (priorityFilter !== void 0 && item.priority !== priorityFilter)
+      return false;
+    if (statusFilter && item.status !== statusFilter)
+      return false;
+    if (assigneeModeFilter === "assigned" && !item.assignee)
+      return false;
+    if (assigneeModeFilter === "unassigned" && item.assignee)
+      return false;
+    if (assigneeFilter !== void 0 && item.assignee !== assigneeFilter) {
+      return false;
+    }
+    if (sprintFilter !== void 0 && item.sprint !== sprintFilter)
+      return false;
+    if (releaseFilter !== void 0 && item.release !== releaseFilter)
+      return false;
+    if (!matchesRuntimeFilters(item, runtimeFieldFilters))
+      return false;
+    return true;
+  });
+}
+function includeEventInWindow(event, start, end) {
+  if (start && compareTimestampStrings(event.at, start) < 0) {
+    return false;
+  }
+  if (end && compareTimestampStrings(event.at, end) >= 0) {
+    return false;
+  }
+  return true;
+}
+function resolveCalendarBoundaryInput(raw, nowValue, fieldLabel) {
+  if (raw.trim().toLowerCase() === "today") {
+    return startOfUtcDay(nowValue);
+  }
+  return resolveIsoOrRelative(raw, new Date(nowValue), fieldLabel);
+}
+function buildRange(view, options, nowValue) {
+  const anchor = options.date ? resolveCalendarBoundaryInput(options.date, nowValue, "--date") : nowValue;
+  const includePast = options.past === true;
+  const fullPeriodRequested = options.fullPeriod === true;
+  const from = options.from ? resolveCalendarBoundaryInput(options.from, nowValue, "--from") : void 0;
+  const to = options.to ? resolveCalendarBoundaryInput(options.to, nowValue, "--to") : void 0;
+  if (from && to && compareTimestampStrings(from, to) >= 0) {
+    throw new PmCliError("Calendar --from must be before --to", EXIT_CODE.USAGE);
+  }
+  if (view !== "agenda" && (options.from !== void 0 || options.to !== void 0)) {
+    throw new PmCliError("--from and --to are only supported for --view agenda", EXIT_CODE.USAGE);
+  }
+  if (view === "agenda") {
+    if (fullPeriodRequested) {
+      throw new PmCliError("--full-period is only supported for --view day|week|month. For agenda windows, use --from and --to.", EXIT_CODE.USAGE);
+    }
+    const start2 = from ?? (options.date ? anchor : includePast ? void 0 : nowValue);
+    return {
+      anchor,
+      start: start2,
+      end: to,
+      fullPeriod: false
+    };
+  }
+  if (view === "day") {
+    const dayStart = startOfUtcDay(anchor);
+    const fullPeriod2 = includePast || fullPeriodRequested;
+    const start2 = fullPeriod2 ? dayStart : maxTimestamp(dayStart, nowValue);
+    return {
+      anchor,
+      start: start2,
+      end: addUtcDays(dayStart, 1),
+      periodStart: dayStart,
+      periodEnd: addUtcDays(dayStart, 1),
+      fullPeriod: fullPeriod2
+    };
+  }
+  if (view === "week") {
+    const weekStart = startOfUtcWeekMonday(anchor);
+    const fullPeriod2 = includePast || fullPeriodRequested;
+    const start2 = fullPeriod2 ? weekStart : maxTimestamp(weekStart, nowValue);
+    return {
+      anchor,
+      start: start2,
+      end: addUtcDays(weekStart, 7),
+      periodStart: weekStart,
+      periodEnd: addUtcDays(weekStart, 7),
+      fullPeriod: fullPeriod2
+    };
+  }
+  const monthStart = startOfUtcMonth(anchor);
+  const monthEnd = startOfNextUtcMonth(anchor);
+  const fullPeriod = includePast || fullPeriodRequested;
+  const start = fullPeriod ? monthStart : maxTimestamp(monthStart, nowValue);
+  return {
+    anchor,
+    start,
+    end: monthEnd,
+    periodStart: monthStart,
+    periodEnd: monthEnd,
+    fullPeriod
+  };
+}
+function bucketEventsByDay(events) {
+  const dayMap = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const list = dayMap.get(event.date) ?? [];
+    list.push(event);
+    dayMap.set(event.date, list);
+  }
+  return [...dayMap.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([date, dayEvents]) => ({
+    date,
+    count: dayEvents.length,
+    events: sortEvents(dayEvents)
+  }));
+}
+function summarize(events) {
+  const itemIds = /* @__PURE__ */ new Set();
+  const byType = /* @__PURE__ */ new Map();
+  const byStatus = /* @__PURE__ */ new Map();
+  let deadlines = 0;
+  let reminders = 0;
+  let scheduled = 0;
+  let recurringEvents = 0;
+  for (const event of events) {
+    itemIds.add(event.item_id);
+    incrementCount(byType, event.item_type);
+    incrementCount(byStatus, event.item_status);
+    if (event.kind === "deadline") {
+      deadlines += 1;
+    } else if (event.kind === "reminder") {
+      reminders += 1;
+    } else {
+      scheduled += 1;
+      if (event.event_recurring === true) {
+        recurringEvents += 1;
+      }
+    }
+  }
+  return {
+    events: events.length,
+    items: itemIds.size,
+    deadlines,
+    reminders,
+    scheduled,
+    by_kind: {
+      deadline: deadlines,
+      reminder: reminders,
+      event: scheduled
+    },
+    by_type: toSortedCountRecord(byType),
+    by_status: toSortedCountRecord(byStatus),
+    recurring_events: recurringEvents
+  };
+}
+async function runCalendar(options, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const nowValue = nowIso();
+  const view = parseView(options.view);
+  const rangeBounds = buildRange(view, options, nowValue);
+  const limit = parseIntegerLimit(options.limit);
+  const includeSources = parseIncludeSources(options.include);
+  const explicitLookahead = parseNonNegativeInteger(options.recurrenceLookaheadDays, "Calendar recurrence lookahead days");
+  const recurrenceLookbackDays = parseNonNegativeInteger(options.recurrenceLookbackDays, "Calendar recurrence lookback days");
+  const occurrenceLimit = parseNonNegativeInteger(options.occurrenceLimit, "Calendar occurrence limit");
+  if (occurrenceLimit !== void 0 && occurrenceLimit < 1) {
+    throw new PmCliError("Calendar occurrence limit must be >= 1", EXIT_CODE.USAGE);
+  }
+  const eventsOnly = includeSources.has("events") && !includeSources.has("deadlines") && !includeSources.has("reminders");
+  const hasExplicitBounds = options.to !== void 0 || explicitLookahead !== void 0 || occurrenceLimit !== void 0;
+  const eventsOnlyCapApplied = eventsOnly && !hasExplicitBounds;
+  const recurrenceLookaheadDays = eventsOnlyCapApplied ? DEFAULT_EVENTS_ONLY_LOOKAHEAD_DAYS : explicitLookahead;
+  const recurrenceLookbackWindowDays = eventsOnlyCapApplied && recurrenceLookbackDays === void 0 ? 0 : recurrenceLookbackDays;
+  const settings = await readSettings(pmRoot);
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  const runtimeFieldFilters = collectRuntimeFilterValues(options, runtimeFieldRegistry, "calendar");
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const listWarnings = [];
+  if (eventsOnlyCapApplied) {
+    listWarnings.push(`recurring_events_default_cap_applied:lookback=0d,lookahead=${DEFAULT_EVENTS_ONLY_LOOKAHEAD_DAYS}d -- use --recurrence-lookback-days/--recurrence-lookahead-days or --to for wider range`);
+  }
+  const items = await listAllFrontMatterLight(pmRoot, settings.item_format, typeRegistry.type_to_folder, listWarnings, settings.schema);
+  const filteredItems = filterItems(items, options, typeRegistry, statusRegistry, runtimeFieldFilters);
+  const recurringWindow = buildRecurringEventWindow(rangeBounds.start, rangeBounds.end, nowValue, recurrenceLookbackWindowDays, recurrenceLookaheadDays);
+  const seededEvents = buildEventSeed(filteredItems, recurringWindow, includeSources, occurrenceLimit);
+  const rangedEvents = seededEvents.filter((event) => includeEventInWindow(event, rangeBounds.start, rangeBounds.end));
+  const limitedEvents = limit === void 0 ? rangedEvents : rangedEvents.slice(0, limit);
+  const days = bucketEventsByDay(limitedEvents);
+  const warnings = [...new Set(listWarnings)].sort((left, right) => left.localeCompare(right));
+  return {
+    view,
+    output_default: "markdown",
+    now: nowValue,
+    anchor: rangeBounds.anchor,
+    range: {
+      start: rangeBounds.start ?? null,
+      end: rangeBounds.end ?? null,
+      period_start: rangeBounds.periodStart ?? null,
+      period_end: rangeBounds.periodEnd ?? null,
+      full_period: rangeBounds.fullPeriod,
+      past: options.past === true,
+      from: options.from ?? null,
+      to: options.to ?? null
+    },
+    filters: {
+      type: options.type ?? null,
+      tag: options.tag ?? null,
+      priority: options.priority ?? null,
+      status: options.status ?? null,
+      assignee: options.assignee ?? null,
+      assignee_filter: options.assigneeFilter ?? null,
+      sprint: options.sprint ?? null,
+      release: options.release ?? null,
+      runtime_filters: runtimeFieldFilters,
+      limit: options.limit ?? null,
+      include: options.include ?? null,
+      full_period: options.fullPeriod === true ? "true" : null,
+      recurrence_lookahead_days: options.recurrenceLookaheadDays ?? null,
+      recurrence_lookback_days: options.recurrenceLookbackDays ?? null,
+      occurrence_limit: options.occurrenceLimit ?? null
+    },
+    summary: summarize(limitedEvents),
+    events: limitedEvents,
+    days,
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+
+// dist/cli/commands/context.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] = "d5f50a52-85aa-5e3d-b803-9c1500b4320c");
+  } catch (e2) {
+  }
+})();
+var CONTEXT_OUTPUT_VALUES = ["markdown", "toon", "json"];
+var HIGH_LEVEL_TYPES = /* @__PURE__ */ new Set(["Epic", "Feature"]);
+var DEFAULT_CONTEXT_LIMIT = 10;
+var STANDARD_SECTIONS = ["hierarchy", "activity", "progress", "workload"];
+var DEEP_SECTIONS = [
+  ...STANDARD_SECTIONS,
+  "blockers",
+  "files",
+  "staleness",
+  "tests"
+];
+function parseOutputFormat(raw) {
+  if (!raw)
+    return void 0;
+  const normalized = raw.trim().toLowerCase();
+  if (!CONTEXT_OUTPUT_VALUES.includes(normalized)) {
+    throw new PmCliError("Context format must be one of markdown|toon|json", EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function resolveContextOutputFormat(options, global2) {
+  const commandFormat = parseOutputFormat(options.format);
+  if (global2.json && commandFormat && commandFormat !== "json") {
+    throw new PmCliError("Cannot combine --json with --format markdown|toon", EXIT_CODE.USAGE);
+  }
+  if (global2.json) {
+    return "json";
+  }
+  return commandFormat ?? "toon";
+}
+function parseContextLimit(raw) {
+  return parseIntegerLimit(raw, "--limit") ?? DEFAULT_CONTEXT_LIMIT;
+}
+function parseContextDepth(raw, settings) {
+  if (!raw)
+    return settings.default_depth;
+  const normalized = raw.trim().toLowerCase();
+  if (!CONTEXT_DEPTH_VALUES.includes(normalized)) {
+    throw new PmCliError(`Context --depth must be one of ${CONTEXT_DEPTH_VALUES.join("|")}`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseContextSections(raw, depth, settings) {
+  if (raw && raw.length > 0) {
+    const sections = [];
+    for (const value of raw) {
+      const normalized = value.trim().toLowerCase();
+      if (!CONTEXT_SECTION_VALUES.includes(normalized)) {
+        throw new PmCliError(`Context --section must be one of ${CONTEXT_SECTION_VALUES.join("|")}`, EXIT_CODE.USAGE);
+      }
+      if (!sections.includes(normalized)) {
+        sections.push(normalized);
+      }
+    }
+    return sections;
+  }
+  if (depth === "brief")
+    return [];
+  const pool = depth === "deep" ? DEEP_SECTIONS : STANDARD_SECTIONS;
+  return pool.filter((section) => settings.sections[section]);
+}
+function parseActivityLimit(raw, settings) {
+  if (!raw)
+    return settings.activity_limit;
+  return parseIntegerLimit(raw, "--activity-limit") ?? settings.activity_limit;
+}
+function parseStaleThresholdDays(raw, settings) {
+  if (!raw)
+    return settings.stale_threshold_days;
+  const trimmed = raw.trim().toLowerCase();
+  const match = /^(\d+)d?$/.exec(trimmed);
+  if (!match) {
+    throw new PmCliError("--stale-threshold must be a number of days (e.g. 7 or 7d)", EXIT_CODE.USAGE);
+  }
+  const days = parseInt(match[1], 10);
+  if (days <= 0) {
+    throw new PmCliError("--stale-threshold must be positive", EXIT_CODE.USAGE);
+  }
+  return days;
+}
+function statusRank(status, statusRegistry) {
+  const normalizedStatus = normalizeStatusForRegistry(status, statusRegistry);
+  const inProgressStatus = normalizeStatusInput("in_progress", statusRegistry);
+  const openStatus = normalizeStatusInput("open", statusRegistry) ?? statusRegistry.open_status;
+  const blockedStatus = normalizeStatusInput("blocked", statusRegistry);
+  const draftStatus = normalizeStatusInput("draft", statusRegistry);
+  if (inProgressStatus && normalizedStatus === inProgressStatus)
+    return 0;
+  if (openStatus && normalizedStatus === openStatus)
+    return 1;
+  if (blockedStatus && normalizedStatus === blockedStatus)
+    return 2;
+  if (draftStatus && normalizedStatus === draftStatus)
+    return 3;
+  if (statusRegistry.active_statuses.has(normalizedStatus))
+    return 4;
+  if (statusRegistry.blocked_statuses.has(normalizedStatus))
+    return 5;
+  if (statusRegistry.terminal_statuses.has(normalizedStatus))
+    return 7;
+  return 6;
+}
+function isClosedStatus(status, statusRegistry) {
+  const closeStatus = normalizeStatusInput("closed", statusRegistry);
+  return closeStatus ? normalizeStatusForRegistry(status, statusRegistry) === closeStatus : false;
+}
+function isInProgressStatus(status, statusRegistry) {
+  const inProgressStatus = normalizeStatusInput("in_progress", statusRegistry);
+  return inProgressStatus ? normalizeStatusForRegistry(status, statusRegistry) === inProgressStatus : false;
+}
+function isOpenStatus(status, statusRegistry) {
+  const openStatus = normalizeStatusInput("open", statusRegistry) ?? statusRegistry.open_status;
+  return normalizeStatusForRegistry(status, statusRegistry) === openStatus;
+}
+function isBlockedStatus(status, statusRegistry) {
+  return statusRegistry.blocked_statuses.has(normalizeStatusForRegistry(status, statusRegistry));
+}
+var LIST_PROJECTION_FLAGS = ["compact", "brief", "fields", "includeBody", "include_body"];
+function stripListProjectionFlags(options) {
+  const copy = { ...options };
+  for (const key of LIST_PROJECTION_FLAGS) {
+    delete copy[key];
+  }
+  return copy;
+}
+function compareOptionalOrder(left, right) {
+  const leftValue = left ?? null;
+  const rightValue = right ?? null;
+  if (leftValue === null && rightValue === null)
+    return 0;
+  if (leftValue === null)
+    return 1;
+  if (rightValue === null)
+    return -1;
+  return leftValue - rightValue;
+}
+function compareOptionalDeadline(left, right) {
+  const leftValue = left ?? null;
+  const rightValue = right ?? null;
+  if (leftValue === null && rightValue === null)
+    return 0;
+  if (leftValue === null)
+    return 1;
+  if (rightValue === null)
+    return -1;
+  return compareTimestampStrings(leftValue, rightValue);
+}
+function compareCriticalItems(left, right, statusRegistry) {
+  const byStatus = statusRank(left.status, statusRegistry) - statusRank(right.status, statusRegistry);
+  if (byStatus !== 0)
+    return byStatus;
+  const byPriority = left.priority - right.priority;
+  if (byPriority !== 0)
+    return byPriority;
+  const byOrder = compareOptionalOrder(left.order, right.order);
+  if (byOrder !== 0)
+    return byOrder;
+  const byDeadline = compareOptionalDeadline(left.deadline, right.deadline);
+  if (byDeadline !== 0)
+    return byDeadline;
+  const byUpdated = compareTimestampStrings(right.updated_at, left.updated_at);
+  const byId = left.id.localeCompare(right.id);
+  return byUpdated !== 0 ? byUpdated : byId;
+}
+function toContextFocusItem(item) {
+  return {
+    id: item.id,
+    title: item.title,
+    type: item.type,
+    status: item.status,
+    priority: item.priority,
+    order: item.order ?? null,
+    deadline: item.deadline ?? null,
+    assignee: item.assignee ?? null,
+    tags: Array.isArray(item.tags) ? [...item.tags] : [],
+    updated_at: item.updated_at
+  };
+}
+function summarizeAgenda(events) {
+  let deadlines = 0;
+  let reminders = 0;
+  let scheduled = 0;
+  const itemIds = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    itemIds.add(event.item_id);
+    if (event.kind === "deadline") {
+      deadlines += 1;
+      continue;
+    }
+    if (event.kind === "reminder") {
+      reminders += 1;
+      continue;
+    }
+    scheduled += 1;
+  }
+  return {
+    events: events.length,
+    items: itemIds.size,
+    deadlines,
+    reminders,
+    scheduled
+  };
+}
+function filterTerminalCalendarEvents(events, statusRegistry) {
+  return events.filter((event) => !statusRegistry.terminal_statuses.has(normalizeStatusForRegistry(event.item_status, statusRegistry)));
+}
+function buildHierarchy(allItems, activeItems, statusRegistry, limit) {
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    itemMap.set(item.id, item);
+  }
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    if (!item.parent)
+      continue;
+    const children = childrenByParent.get(item.parent) ?? [];
+    children.push(item);
+    childrenByParent.set(item.parent, children);
+  }
+  const activeHighLevelIds = new Set(activeItems.filter((item) => HIGH_LEVEL_TYPES.has(item.type)).map((item) => item.id));
+  const nodes = [];
+  for (const parentId of activeHighLevelIds) {
+    const parent = itemMap.get(parentId);
+    if (!parent)
+      continue;
+    const allDescendants = collectDescendants(parentId, childrenByParent);
+    const childItems = childrenByParent.get(parentId) ?? [];
+    let closedCount = 0;
+    let openCount = 0;
+    let inProgressCount = 0;
+    let blockedCount = 0;
+    for (const desc of allDescendants) {
+      if (isClosedStatus(desc.status, statusRegistry))
+        closedCount++;
+      else if (isInProgressStatus(desc.status, statusRegistry))
+        inProgressCount++;
+      else if (isBlockedStatus(desc.status, statusRegistry))
+        blockedCount++;
+      else if (isOpenStatus(desc.status, statusRegistry))
+        openCount++;
+    }
+    const children = childItems.sort((a, b) => compareCriticalItems(a, b, statusRegistry)).slice(0, limit).map((child) => {
+      const grandchildren = collectDescendants(child.id, childrenByParent);
+      const gcClosed = grandchildren.filter((gc) => isClosedStatus(gc.status, statusRegistry)).length;
+      return {
+        id: child.id,
+        title: child.title,
+        type: child.type,
+        status: child.status,
+        children_total: grandchildren.length,
+        children_closed: gcClosed
+      };
+    });
+    nodes.push({
+      id: parent.id,
+      title: parent.title,
+      type: parent.type,
+      status: parent.status,
+      children_total: allDescendants.length,
+      children_closed: closedCount,
+      children_open: openCount,
+      children_in_progress: inProgressCount,
+      children_blocked: blockedCount,
+      children
+    });
+  }
+  return nodes.sort((a, b) => {
+    const aParent = itemMap.get(a.id);
+    const bParent = itemMap.get(b.id);
+    return compareCriticalItems(aParent, bParent, statusRegistry);
+  }).slice(0, limit);
+}
+function collectDescendants(parentId, childrenByParent) {
+  const result = [];
+  const stack = [parentId];
+  const visited = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const children = childrenByParent.get(current) ?? [];
+    for (const child of children) {
+      result.push(child);
+      stack.push(child.id);
+    }
+  }
+  return result;
+}
+async function buildActivity(activityLimit, global2) {
+  const result = await runActivity({ compact: true, limit: String(activityLimit) }, global2);
+  return result.compact_activity ?? [];
+}
+function buildProgress(allItems, activeItems, statusRegistry, limit) {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    if (!item.parent)
+      continue;
+    const children = childrenByParent.get(item.parent) ?? [];
+    children.push(item);
+    childrenByParent.set(item.parent, children);
+  }
+  const activeHighLevel = activeItems.filter((item) => HIGH_LEVEL_TYPES.has(item.type));
+  const entries = [];
+  for (const parent of activeHighLevel) {
+    const descendants = collectDescendants(parent.id, childrenByParent);
+    const total = descendants.length;
+    if (total === 0)
+      continue;
+    let closed = 0;
+    let open = 0;
+    let inProgress = 0;
+    let blocked = 0;
+    for (const desc of descendants) {
+      if (isClosedStatus(desc.status, statusRegistry))
+        closed++;
+      else if (isInProgressStatus(desc.status, statusRegistry))
+        inProgress++;
+      else if (isBlockedStatus(desc.status, statusRegistry))
+        blocked++;
+      else if (isOpenStatus(desc.status, statusRegistry))
+        open++;
+    }
+    entries.push({
+      id: parent.id,
+      title: parent.title,
+      type: parent.type,
+      total,
+      closed,
+      open,
+      in_progress: inProgress,
+      blocked,
+      completion_pct: total > 0 ? Math.round(closed / total * 100) : 0
+    });
+  }
+  return entries.sort((a, b) => a.completion_pct - b.completion_pct).slice(0, limit);
+}
+function buildBlockers(blockedItems, itemMap, limit) {
+  return blockedItems.slice(0, limit).map((item) => {
+    const blockerItem = item.blocked_by ? itemMap.get(item.blocked_by) : void 0;
+    return {
+      id: item.id,
+      title: item.title,
+      blocked_by: item.blocked_by ?? null,
+      blocked_by_title: blockerItem?.title ?? null,
+      blocked_by_status: blockerItem?.status ?? null,
+      blocked_reason: item.blocked_reason ?? null,
+      unblock_note: item.unblock_note ?? null
+    };
+  });
+}
+function buildHotFiles(activeItems, limit) {
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const item of activeItems) {
+    for (const file of item.files ?? []) {
+      const existing = fileMap.get(file.path) ?? /* @__PURE__ */ new Set();
+      existing.add(item.id);
+      fileMap.set(file.path, existing);
+    }
+  }
+  return [...fileMap.entries()].map(([filePath, itemIds]) => ({
+    path: filePath,
+    references: itemIds.size,
+    items: [...itemIds].sort()
+  })).sort((a, b) => b.references - a.references).slice(0, limit);
+}
+function buildWorkload(activeItems, statusRegistry, limit) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of activeItems) {
+    const key = item.assignee ?? null;
+    const existing = groups.get(key) ?? [];
+    existing.push(item);
+    groups.set(key, existing);
+  }
+  return [...groups.entries()].map(([assignee, items]) => ({
+    assignee,
+    active: items.length,
+    in_progress: items.filter((item) => isInProgressStatus(item.status, statusRegistry)).length,
+    items: items.map((item) => item.id).sort()
+  })).sort((a, b) => b.active - a.active).slice(0, limit);
+}
+function buildStaleness(allNonTerminal, staleThresholdDays, now, limit) {
+  const cutoffMs = new Date(now).getTime() - staleThresholdDays * 24 * 60 * 60 * 1e3;
+  return allNonTerminal.filter((item) => new Date(item.updated_at).getTime() < cutoffMs).map((item) => ({
+    id: item.id,
+    title: item.title,
+    status: item.status,
+    updated_at: item.updated_at,
+    stale_days: Math.floor((new Date(now).getTime() - new Date(item.updated_at).getTime()) / (24 * 60 * 60 * 1e3))
+  })).sort((a, b) => b.stale_days - a.stale_days).slice(0, limit);
+}
+function buildTestHealth(activeItems) {
+  let itemsWithTests = 0;
+  let itemsWithRecentRuns = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  const itemsFailing = [];
+  for (const item of activeItems) {
+    if ((item.tests ?? []).length > 0) {
+      itemsWithTests++;
+    }
+    const runs = item.test_runs ?? [];
+    if (runs.length > 0) {
+      itemsWithRecentRuns++;
+      let itemHasFailure = false;
+      for (const run of runs) {
+        passed += run.passed ?? 0;
+        failed += run.failed ?? 0;
+        skipped += run.skipped ?? 0;
+        if ((run.failed ?? 0) > 0) {
+          itemHasFailure = true;
+        }
+      }
+      if (itemHasFailure) {
+        itemsFailing.push(item.id);
+      }
+    }
+  }
+  return {
+    items_with_tests: itemsWithTests,
+    items_with_recent_runs: itemsWithRecentRuns,
+    recent_runs: { passed, failed, skipped },
+    items_failing: itemsFailing.sort()
+  };
+}
+function formatClock(timestamp) {
+  return `${new Date(timestamp).toISOString().slice(11, 16)}Z`;
+}
+function formatFocusLine(item) {
+  const orderToken = item.order === null ? "-" : String(item.order);
+  const deadlineToken = item.deadline ?? "-";
+  return `${item.id} p${item.priority} ${item.status} ${item.type} order:${orderToken} deadline:${deadlineToken} ${item.title}`;
+}
+function formatAgendaLine(event) {
+  const base = `${formatClock(event.at)} [${event.kind}] ${event.item_id} p${event.item_priority} ${event.item_status} ${event.item_title}`;
+  if (event.kind === "reminder") {
+    return `${base} \u2014 ${event.reminder_text}`;
+  }
+  if (event.kind === "event") {
+    const recurringSuffix = event.event_recurring ? " (recurring)" : "";
+    const title = event.event_title ?? event.item_title;
+    return `${base} \u2014 ${title}${recurringSuffix}`;
+  }
+  return base;
+}
+function renderContextMarkdown(result) {
+  const lines = [];
+  lines.push("# pm context");
+  lines.push("");
+  lines.push(`- now: ${result.now}`);
+  lines.push(`- depth: ${result.depth}`);
+  lines.push(`- active_items: ${result.summary.active_items} (in_progress: ${result.summary.in_progress}, open: ${result.summary.open})`);
+  if (result.summary.total_items !== void 0) {
+    lines.push(`- total_items: ${result.summary.total_items} (closed: ${result.summary.closed ?? 0}, canceled: ${result.summary.canceled ?? 0})`);
+  }
+  lines.push(`- agenda_events: ${result.summary.agenda_events}`);
+  lines.push(`- blocked_fallback_used: ${result.summary.blocked_fallback_used}`);
+  if (result.sections_included.length > 0) {
+    lines.push(`- sections: ${result.sections_included.join(", ")}`);
+  }
+  lines.push("");
+  lines.push("## High-level focus");
+  if (result.high_level.length === 0) {
+    lines.push("No high-level active items.");
+  } else {
+    for (const item of result.high_level) {
+      lines.push(`- ${formatFocusLine(item)}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Low-level focus");
+  if (result.low_level.length === 0) {
+    lines.push("No low-level active items.");
+  } else {
+    for (const item of result.low_level) {
+      lines.push(`- ${formatFocusLine(item)}`);
+    }
+  }
+  lines.push("");
+  if (result.blocked_fallback.length > 0) {
+    lines.push("## Blocked fallback");
+    for (const item of result.blocked_fallback) {
+      lines.push(`- ${formatFocusLine(item)}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Agenda");
+  lines.push(`- events: ${result.agenda.summary.events} (deadlines: ${result.agenda.summary.deadlines}, reminders: ${result.agenda.summary.reminders}, scheduled: ${result.agenda.summary.scheduled})`);
+  if (result.agenda.events.length === 0) {
+    lines.push("No agenda events matched the selected filters.");
+  } else {
+    for (const event of result.agenda.events) {
+      lines.push(`- ${formatAgendaLine(event)}`);
+    }
+  }
+  lines.push("");
+  if (result.hierarchy && result.hierarchy.length > 0) {
+    lines.push("## Hierarchy");
+    for (const node of result.hierarchy) {
+      const pct = node.children_total > 0 ? Math.round(node.children_closed / node.children_total * 100) : 0;
+      lines.push(`- ${node.id} ${node.type} ${node.status} "${node.title}" [${node.children_closed}/${node.children_total} done ${pct}%]`);
+      for (const child of node.children) {
+        const cpct = child.children_total > 0 ? Math.round(child.children_closed / child.children_total * 100) : 0;
+        lines.push(`  - ${child.id} ${child.type} ${child.status} "${child.title}" [${child.children_closed}/${child.children_total} done ${cpct}%]`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.progress && result.progress.length > 0) {
+    lines.push("## Progress");
+    for (const entry of result.progress) {
+      lines.push(`- ${entry.id} "${entry.title}" ${entry.completion_pct}% (${entry.closed}/${entry.total} closed, ${entry.in_progress} wip, ${entry.open} open, ${entry.blocked} blocked)`);
+    }
+    lines.push("");
+  }
+  if (result.activity && result.activity.length > 0) {
+    lines.push("## Recent activity");
+    for (const entry of result.activity) {
+      const msg = entry.msg ? ` ${entry.msg}` : "";
+      lines.push(`- ${entry.ts.slice(0, 16)}Z ${entry.id} ${entry.op} by:${entry.author}${msg}`);
+    }
+    lines.push("");
+  }
+  if (result.blockers && result.blockers.length > 0) {
+    lines.push("## Blockers");
+    for (const entry of result.blockers) {
+      const by = entry.blocked_by ? `blocked_by:${entry.blocked_by}(${entry.blocked_by_status ?? "?"})` : "blocked_by:-";
+      const reason = entry.blocked_reason ? ` reason:"${entry.blocked_reason}"` : "";
+      const note = entry.unblock_note ? ` unblock:"${entry.unblock_note}"` : "";
+      lines.push(`- ${entry.id} "${entry.title}" ${by}${reason}${note}`);
+    }
+    lines.push("");
+  }
+  if (result.files && result.files.length > 0) {
+    lines.push("## Hot files");
+    for (const file of result.files) {
+      lines.push(`- ${file.path} refs:${file.references} items:[${file.items.join(",")}]`);
+    }
+    lines.push("");
+  }
+  if (result.workload && result.workload.length > 0) {
+    lines.push("## Workload");
+    for (const entry of result.workload) {
+      const who = entry.assignee ?? "(unassigned)";
+      lines.push(`- ${who} active:${entry.active} wip:${entry.in_progress} items:[${entry.items.join(",")}]`);
+    }
+    lines.push("");
+  }
+  if (result.staleness && result.staleness.length > 0) {
+    lines.push("## Stale items");
+    for (const entry of result.staleness) {
+      lines.push(`- ${entry.id} ${entry.status} stale:${entry.stale_days}d last:${entry.updated_at.slice(0, 10)} "${entry.title}"`);
+    }
+    lines.push("");
+  }
+  if (result.tests) {
+    lines.push("## Test health");
+    lines.push(`- items_with_tests: ${result.tests.items_with_tests}`);
+    lines.push(`- items_with_recent_runs: ${result.tests.items_with_recent_runs}`);
+    lines.push(`- passed: ${result.tests.recent_runs.passed}, failed: ${result.tests.recent_runs.failed}, skipped: ${result.tests.recent_runs.skipped}`);
+    if (result.tests.items_failing.length > 0) {
+      lines.push(`- items_failing: [${result.tests.items_failing.join(",")}]`);
+    }
+    lines.push("");
+  }
+  const isEmpty = result.summary.active_items === 0 && result.summary.blocked === 0 && result.agenda.summary.events === 0;
+  if (isEmpty) {
+    lines.push("## Suggestions");
+    lines.push("No active work items or upcoming events. Consider:");
+    lines.push('- `pm create --type Task --title "..."` to add a new work item');
+    lines.push("- `pm list --status closed --limit 5` to review recent completions");
+    lines.push("- `pm search <keywords>` to find related past work");
+    lines.push("- `pm aggregate` for a full project status overview");
+  }
+  return lines.join("\n");
+}
+async function runContext(options, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  const settings = await readSettings(pmRoot);
+  const contextSettings = settings.context ?? SETTINGS_DEFAULTS.context;
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const limit = parseContextLimit(options.limit);
+  const depth = parseContextDepth(options.depth, contextSettings);
+  const sectionsIncluded = parseContextSections(options.section, depth, contextSettings);
+  const activityLimit = parseActivityLimit(options.activityLimit, contextSettings);
+  const staleThresholdDays = parseStaleThresholdDays(options.staleThreshold, contextSettings);
+  const needsAllItems = sectionsIncluded.some((s) => ["hierarchy", "progress", "blockers", "staleness"].includes(s));
+  const baseListOptions = stripListProjectionFlags(options);
+  const listOptions = { ...baseListOptions, excludeTerminal: true };
+  const listed = await runList(void 0, listOptions, global2);
+  const listedFrontMatter = listed.items;
+  let allItems = listedFrontMatter;
+  if (needsAllItems) {
+    const allListOptions = { ...baseListOptions, excludeTerminal: false };
+    const allListed = await runList(void 0, allListOptions, global2);
+    allItems = allListed.items;
+  }
+  const ranked = [...listedFrontMatter].sort((left, right) => compareCriticalItems(left, right, statusRegistry));
+  const activeStatuses = statusRegistry.active_statuses.size > 0 ? statusRegistry.active_statuses : /* @__PURE__ */ new Set([statusRegistry.open_status]);
+  const blockedStatuses = statusRegistry.blocked_statuses;
+  const activeItems = ranked.filter((item) => activeStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+  const blockedItems = ranked.filter((item) => blockedStatuses.has(normalizeStatusForRegistry(item.status, statusRegistry)));
+  const highLevel = activeItems.filter((item) => HIGH_LEVEL_TYPES.has(item.type)).slice(0, limit).map(toContextFocusItem);
+  const lowLevel = activeItems.filter((item) => !HIGH_LEVEL_TYPES.has(item.type)).slice(0, limit).map(toContextFocusItem);
+  const blockedFallbackUsed = activeItems.length === 0;
+  const blockedFallback = blockedFallbackUsed ? blockedItems.slice(0, limit).map(toContextFocusItem) : [];
+  const calendarOptions = {
+    ...baseListOptions,
+    view: "agenda",
+    include: "all",
+    limit: String(limit)
+  };
+  const agenda = await runCalendar(calendarOptions, global2);
+  const agendaEvents = filterTerminalCalendarEvents(agenda.events, statusRegistry).slice(0, limit);
+  const agendaSummary = summarizeAgenda(agendaEvents);
+  const warnings = [.../* @__PURE__ */ new Set([...listed.warnings ?? [], ...agenda.warnings ?? []])].sort((left, right) => left.localeCompare(right));
+  const inProgressStatus = normalizeStatusInput("in_progress", statusRegistry);
+  const openStatus = normalizeStatusInput("open", statusRegistry) ?? statusRegistry.open_status;
+  const inProgressCount = inProgressStatus ? activeItems.filter((item) => normalizeStatusForRegistry(item.status, statusRegistry) === inProgressStatus).length : 0;
+  const openCount = activeItems.filter((item) => normalizeStatusForRegistry(item.status, statusRegistry) === openStatus).length;
+  const now = agenda.now;
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const item of allItems) {
+    itemMap.set(item.id, item);
+  }
+  const allNonTerminal = allItems.filter((item) => !isTerminalStatus(item.status, statusRegistry));
+  const has = (section) => sectionsIncluded.includes(section);
+  const hierarchy = has("hierarchy") ? buildHierarchy(allItems, activeItems, statusRegistry, limit) : void 0;
+  const activity = has("activity") ? await buildActivity(activityLimit, global2) : void 0;
+  const progress = has("progress") ? buildProgress(allItems, activeItems, statusRegistry, limit) : void 0;
+  const blockersSection = has("blockers") ? buildBlockers(blockedItems, itemMap, limit) : void 0;
+  const filesSection = has("files") ? buildHotFiles(activeItems, limit) : void 0;
+  const workload = has("workload") ? buildWorkload(activeItems, statusRegistry, limit) : void 0;
+  const staleness = has("staleness") ? buildStaleness(allNonTerminal, staleThresholdDays, now, limit) : void 0;
+  const tests = has("tests") ? buildTestHealth(activeItems) : void 0;
+  const summaryExtras = needsAllItems ? {
+    total_items: allItems.length,
+    closed: allItems.filter((i) => isClosedStatus(i.status, statusRegistry)).length,
+    canceled: allItems.filter((i) => {
+      const canceledStatus = normalizeStatusInput("canceled", statusRegistry);
+      return canceledStatus ? normalizeStatusForRegistry(i.status, statusRegistry) === canceledStatus : false;
+    }).length
+  } : {};
+  const result = {
+    output_default: "toon",
+    now,
+    depth,
+    sections_included: sectionsIncluded,
+    window: {
+      anchor: agenda.anchor,
+      start: agenda.range.start,
+      end: agenda.range.end,
+      past: agenda.range.past,
+      from: agenda.range.from,
+      to: agenda.range.to
+    },
+    filters: {
+      type: options.type ?? null,
+      tag: options.tag ?? null,
+      priority: options.priority ?? null,
+      assignee: options.assignee ?? null,
+      assignee_filter: options.assigneeFilter ?? null,
+      sprint: options.sprint ?? null,
+      release: options.release ?? null,
+      limit: options.limit ?? null,
+      runtime_filters: listed.filters.runtime_filters ?? agenda.filters.runtime_filters ?? {}
+    },
+    summary: {
+      active_items: activeItems.length,
+      in_progress: inProgressCount,
+      open: openCount,
+      blocked: blockedItems.length,
+      blocked_fallback_used: blockedFallbackUsed,
+      high_level: highLevel.length,
+      low_level: lowLevel.length,
+      agenda_events: agendaSummary.events,
+      ...summaryExtras
+    },
+    high_level: highLevel,
+    low_level: lowLevel,
+    blocked_fallback: blockedFallback,
+    agenda: {
+      summary: agendaSummary,
+      events: agendaEvents
+    }
+  };
+  if (hierarchy)
+    result.hierarchy = hierarchy;
+  if (activity)
+    result.activity = activity;
+  if (progress)
+    result.progress = progress;
+  if (blockersSection)
+    result.blockers = blockersSection;
+  if (filesSection)
+    result.files = filesSection;
+  if (workload)
+    result.workload = workload;
+  if (staleness)
+    result.staleness = staleness;
+  if (tests)
+    result.tests = tests;
+  if (warnings.length > 0)
+    result.warnings = warnings;
+  if (activeItems.length === 0 && blockedItems.length === 0 && agendaEvents.length === 0) {
+    result.suggestions = [
+      'pm create --type Task --title "..." to add a new work item',
+      "pm list --status closed --limit 5 to review recent completions",
+      "pm search <keywords> to find related past work",
+      "pm aggregate for a full project status overview"
+    ];
+  }
+  return result;
+}
+export {
+  CONTEXT_OUTPUT_VALUES,
+  parseContextDepth,
+  parseContextSections,
+  renderContextMarkdown,
+  resolveContextOutputFormat,
+  runContext
+};
+//# sourceMappingURL=context-RZ5QPNJB.js.map