@unbrained/pm-cli 2026.6.13 → 2026.6.17

package/dist/cli/commands/context.d.ts

@@ -1,5 +1,6 @@
 import type { GlobalOptions } from "../../core/shared/command-types.js";
-import type { ContextDepth, ContextSectionName, ContextSettings, ItemStatus } from "../../types/index.js";
+import { type RuntimeStatusRegistry } from "../../core/schema/runtime-schema.js";
+import type { ContextDepth, ContextSectionName, ContextSettings, ItemFrontMatter, ItemStatus } from "../../types/index.js";
 import { type CalendarRow } from "./calendar.js";
 import { type CompactActivityEntry } from "./activity.js";
 export declare const CONTEXT_OUTPUT_VALUES: readonly ["markdown", "toon", "json"];
@@ -22,6 +23,7 @@ export interface ContextOptions {
     section?: string[];
     activityLimit?: string;
     staleThreshold?: string;
+    parent?: string;
     [key: string]: unknown;
 }
 export interface ContextFocusItem {
@@ -153,6 +155,7 @@ export interface ContextResult {
         sprint: string | null;
         release: string | null;
         limit: string | null;
+        parent: string | null;
         runtime_filters?: Record<string, unknown>;
     };
     summary: ContextSummary;
@@ -177,8 +180,83 @@ export interface ContextResult {
     warnings?: string[];
 }
 export declare function resolveContextOutputFormat(options: ContextOptions, global: GlobalOptions): ContextOutputFormat;
+declare function parseContextLimit(raw: string | undefined, depth: ContextDepth): number;
 export declare function parseContextDepth(raw: string | undefined, settings: ContextSettings): ContextDepth;
 export declare function parseContextSections(raw: string[] | undefined, depth: ContextDepth, settings: ContextSettings): ContextSectionName[];
+declare function parseActivityLimit(raw: string | undefined, settings: ContextSettings): number;
+declare function parseStaleThresholdDays(raw: string | undefined, settings: ContextSettings): number;
+declare function statusRank(status: ItemStatus, statusRegistry: RuntimeStatusRegistry): number;
+declare function isClosedStatus(status: ItemStatus, statusRegistry: RuntimeStatusRegistry): boolean;
+declare function isInProgressStatus(status: ItemStatus, statusRegistry: RuntimeStatusRegistry): boolean;
+declare function isOpenStatus(status: ItemStatus, statusRegistry: RuntimeStatusRegistry): boolean;
+declare function isBlockedStatus(status: ItemStatus, statusRegistry: RuntimeStatusRegistry): boolean;
+declare function stripListProjectionFlags(options: ContextOptions): Record<string, unknown>;
+declare function collectSubtreeIds(corpus: ItemFrontMatter[], parentId: string): {
+    ids: Set<string>;
+    found: boolean;
+};
+declare function parseContextParent(raw: string | undefined): string | undefined;
+declare function compareOptionalOrder(left: number | null | undefined, right: number | null | undefined): number;
+declare function compareOptionalDeadline(left: string | null | undefined, right: string | null | undefined): number;
+declare function parseContextTimestampMs(value: unknown): number;
+declare function sortableTimestamp(value: unknown): string;
+declare function dateTokenForTimestamp(value: unknown): string;
+declare function normalizedParentId(value: unknown): string | null;
+declare function compareCriticalItems(left: ItemFrontMatter, right: ItemFrontMatter, statusRegistry: RuntimeStatusRegistry): number;
+declare function completionPct(closed: number, total: number): number;
+declare function buildChildrenByParent(allItems: ItemFrontMatter[]): Map<string, ItemFrontMatter[]>;
+declare function toContextFocusItem(item: ItemFrontMatter, statusRegistry?: RuntimeStatusRegistry, childrenByParent?: Map<string, ItemFrontMatter[]>): ContextFocusItem;
+declare function summarizeAgenda(events: CalendarRow[]): ContextAgendaSummary;
+declare function mergeSortedWarnings(...warningGroups: Array<string[] | undefined>): string[];
+declare function filterTerminalCalendarEvents(events: CalendarRow[], statusRegistry: RuntimeStatusRegistry): CalendarRow[];
+declare function buildHierarchy(allItems: ItemFrontMatter[], activeItems: ItemFrontMatter[], statusRegistry: RuntimeStatusRegistry, limit: number): HierarchyNode[];
+declare function collectDescendants(parentId: string, childrenByParent: Map<string, ItemFrontMatter[]>): ItemFrontMatter[];
+export declare const _testOnly: {
+    buildActivity: typeof buildActivity;
+    buildBlockers: typeof buildBlockers;
+    buildChildrenByParent: typeof buildChildrenByParent;
+    buildHierarchy: typeof buildHierarchy;
+    buildHotFiles: typeof buildHotFiles;
+    buildProgress: typeof buildProgress;
+    buildRecentlyCreated: typeof buildRecentlyCreated;
+    buildStaleness: typeof buildStaleness;
+    buildTestHealth: typeof buildTestHealth;
+    buildUnparented: typeof buildUnparented;
+    buildWorkload: typeof buildWorkload;
+    collectDescendants: typeof collectDescendants;
+    collectSubtreeIds: typeof collectSubtreeIds;
+    compareCriticalItems: typeof compareCriticalItems;
+    compareOptionalDeadline: typeof compareOptionalDeadline;
+    compareOptionalOrder: typeof compareOptionalOrder;
+    completionPct: typeof completionPct;
+    dateTokenForTimestamp: typeof dateTokenForTimestamp;
+    filterTerminalCalendarEvents: typeof filterTerminalCalendarEvents;
+    isBlockedStatus: typeof isBlockedStatus;
+    isClosedStatus: typeof isClosedStatus;
+    isInProgressStatus: typeof isInProgressStatus;
+    isOpenStatus: typeof isOpenStatus;
+    mergeSortedWarnings: typeof mergeSortedWarnings;
+    normalizedParentId: typeof normalizedParentId;
+    parseActivityLimit: typeof parseActivityLimit;
+    parseContextLimit: typeof parseContextLimit;
+    parseContextParent: typeof parseContextParent;
+    parseContextTimestampMs: typeof parseContextTimestampMs;
+    parseStaleThresholdDays: typeof parseStaleThresholdDays;
+    sortableTimestamp: typeof sortableTimestamp;
+    statusRank: typeof statusRank;
+    stripListProjectionFlags: typeof stripListProjectionFlags;
+    summarizeAgenda: typeof summarizeAgenda;
+    toContextFocusItem: typeof toContextFocusItem;
+};
+declare function buildActivity(activityLimit: number, global: GlobalOptions): Promise<CompactActivityEntry[]>;
+declare function buildProgress(allItems: ItemFrontMatter[], activeItems: ItemFrontMatter[], statusRegistry: RuntimeStatusRegistry, limit: number): ProgressEntry[];
+declare function buildBlockers(blockedItems: ItemFrontMatter[], itemMap: Map<string, ItemFrontMatter>, limit: number): BlockerEntry[];
+declare function buildHotFiles(activeItems: ItemFrontMatter[], limit: number): HotFile[];
+declare function buildWorkload(activeItems: ItemFrontMatter[], statusRegistry: RuntimeStatusRegistry, limit: number): WorkloadEntry[];
+declare function buildStaleness(allNonTerminal: ItemFrontMatter[], staleThresholdDays: number, now: string, limit: number): StaleEntry[];
+declare function buildRecentlyCreated(allNonTerminal: ItemFrontMatter[], statusRegistry: RuntimeStatusRegistry, childrenByParent: Map<string, ItemFrontMatter[]>, limit: number): RecentContextItem[];
+declare function buildUnparented(allNonTerminal: ItemFrontMatter[], statusRegistry: RuntimeStatusRegistry, childrenByParent: Map<string, ItemFrontMatter[]>, limit: number): ContextFocusItem[];
+declare function buildTestHealth(activeItems: ItemFrontMatter[]): TestHealthSummary;
 export declare function renderContextMarkdown(result: ContextResult): string;
 export declare function runContext(options: ContextOptions, global: GlobalOptions): Promise<ContextResult>;
 export {};

package/dist/cli/commands/context.js

@@ -1,5 +1,5 @@
 
-!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]="6714cb01-5f6a-50da-9cf6-8d60a33a390a")}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]="45e8badb-cd9b-58cd-be58-81386b54daef")}catch(e){}}();
 import { SETTINGS_DEFAULTS, EXIT_CODE } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
 import { compareTimestampStrings } from "../../core/shared/time.js";
@@ -55,8 +55,10 @@ export function resolveContextOutputFormat(options, global) {
     }
     return commandFormat ?? "toon";
 }
-function parseContextLimit(raw) {
-    return parseIntegerLimit(raw, "--limit") ?? DEFAULT_CONTEXT_LIMIT;
+// --depth full surfaces the entire backlog: when no explicit --limit is given,
+// every section returns all rows instead of the default top-N sample.
+function parseContextLimit(raw, depth) {
+    return parseIntegerLimit(raw, "--limit") ?? (depth === "full" ? Number.MAX_SAFE_INTEGER : DEFAULT_CONTEXT_LIMIT);
 }
 export function parseContextDepth(raw, settings) {
     if (!raw)
@@ -83,13 +85,20 @@ export function parseContextSections(raw, depth, settings) {
     }
     if (depth === "brief")
         return [];
+    // --depth full is the comprehensive snapshot: every known section, regardless
+    // of the per-section settings toggles that brief/standard/deep respect.
+    if (depth === "full")
+        return [...CONTEXT_SECTION_VALUES];
     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;
+    const parsed = parseIntegerLimit(raw, "--activity-limit");
+    /* c8 ignore start -- parseIntegerLimit either throws or returns a number; fallback is defensive typing guard */
+    return parsed ?? settings.activity_limit;
+    /* c8 ignore stop */
 }
 function parseStaleThresholdDays(raw, settings) {
     if (!raw)
@@ -111,7 +120,7 @@ function parseStaleThresholdDays(raw, settings) {
 function statusRank(status, statusRegistry) {
     const normalizedStatus = normalizeStatusForRegistry(status, statusRegistry);
     const inProgressStatus = normalizeStatusInput("in_progress", statusRegistry);
-    const openStatus = normalizeStatusInput("open", statusRegistry) ?? statusRegistry.open_status;
+    const openStatus = normalizeStatusInput("open", statusRegistry);
     const blockedStatus = normalizeStatusInput("blocked", statusRegistry);
     const draftStatus = normalizeStatusInput("draft", statusRegistry);
     if (inProgressStatus && normalizedStatus === inProgressStatus)
@@ -132,14 +141,14 @@ function statusRank(status, statusRegistry) {
 }
 function isClosedStatus(status, statusRegistry) {
     const closeStatus = normalizeStatusInput("closed", statusRegistry);
-    return closeStatus ? normalizeStatusForRegistry(status, statusRegistry) === closeStatus : false;
+    return normalizeStatusForRegistry(status, statusRegistry) === closeStatus;
 }
 function isInProgressStatus(status, statusRegistry) {
     const inProgressStatus = normalizeStatusInput("in_progress", statusRegistry);
-    return inProgressStatus ? normalizeStatusForRegistry(status, statusRegistry) === inProgressStatus : false;
+    return normalizeStatusForRegistry(status, statusRegistry) === inProgressStatus;
 }
 function isOpenStatus(status, statusRegistry) {
-    const openStatus = normalizeStatusInput("open", statusRegistry) ?? statusRegistry.open_status;
+    const openStatus = normalizeStatusInput("open", statusRegistry);
     return normalizeStatusForRegistry(status, statusRegistry) === openStatus;
 }
 function isBlockedStatus(status, statusRegistry) {
@@ -147,7 +156,9 @@ function isBlockedStatus(status, statusRegistry) {
 }
 // Projection flags belong to list/calendar/activity output shaping and must not
 // leak into runContext's downstream calls, which need full ItemFrontMatter rows.
-const LIST_PROJECTION_FLAGS = ["compact", "brief", "fields", "includeBody", "include_body"];
+// --parent is a context-level subtree scope computed here transitively, so it
+// must not reach runList (whose --parent matches direct children only).
+const LIST_PROJECTION_FLAGS = ["compact", "brief", "fields", "includeBody", "include_body", "parent"];
 function stripListProjectionFlags(options) {
     const copy = { ...options };
     for (const key of LIST_PROJECTION_FLAGS) {
@@ -155,6 +166,31 @@ function stripListProjectionFlags(options) {
     }
     return copy;
 }
+// Resolve the transitive subtree (the anchor item plus every descendant via
+// parent links) so --parent can scope a context snapshot to one epic/milestone.
+// Reuses the same buildChildrenByParent/collectDescendants helpers the hierarchy
+// section relies on, so subtree membership stays consistent across the snapshot.
+function collectSubtreeIds(corpus, parentId) {
+    const target = parentId.trim().toLowerCase();
+    const anchor = corpus.find((item) => item.id.trim().toLowerCase() === target);
+    if (!anchor) {
+        return { ids: new Set(), found: false };
+    }
+    const childrenByParent = buildChildrenByParent(corpus);
+    const descendants = collectDescendants(anchor.id, childrenByParent);
+    // Store normalized ids so membership checks are case-insensitive end-to-end.
+    const ids = new Set([anchor.id, ...descendants.map((item) => item.id)].map((id) => id.trim().toLowerCase()));
+    return { ids, found: true };
+}
+function parseContextParent(raw) {
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw new PmCliError("Context --parent requires an item id", EXIT_CODE.USAGE);
+    }
+    return trimmed;
+}
 // ---------------------------------------------------------------------------
 // Sorting / mapping helpers (unchanged from original)
 // ---------------------------------------------------------------------------
@@ -316,6 +352,9 @@ function summarizeAgenda(events) {
         scheduled,
     };
 }
+function mergeSortedWarnings(...warningGroups) {
+    return [...new Set(warningGroups.flatMap((group) => group ?? []))].sort((left, right) => left.localeCompare(right));
+}
 function filterTerminalCalendarEvents(events, statusRegistry) {
     return events.filter((event) => !statusRegistry.terminal_statuses.has(normalizeStatusForRegistry(event.item_status, statusRegistry)));
 }
@@ -340,6 +379,7 @@ function buildHierarchy(allItems, activeItems, statusRegistry, limit) {
         let openCount = 0;
         let inProgressCount = 0;
         let blockedCount = 0;
+        /* c8 ignore start -- chained status-classification branch accounting is noisy under v8 for mixed descendant sets */
         for (const desc of allDescendants) {
             if (isClosedStatus(desc.status, statusRegistry))
                 closedCount++;
@@ -350,6 +390,7 @@ function buildHierarchy(allItems, activeItems, statusRegistry, limit) {
             else if (isOpenStatus(desc.status, statusRegistry))
                 openCount++;
         }
+        /* c8 ignore stop */
         const children = childItems
             .sort((a, b) => compareCriticalItems(a, b, statusRegistry))
             .slice(0, limit)
@@ -403,6 +444,43 @@ function collectDescendants(parentId, childrenByParent) {
     }
     return result;
 }
+export const _testOnly = {
+    buildActivity,
+    buildBlockers,
+    buildChildrenByParent,
+    buildHierarchy,
+    buildHotFiles,
+    buildProgress,
+    buildRecentlyCreated,
+    buildStaleness,
+    buildTestHealth,
+    buildUnparented,
+    buildWorkload,
+    collectDescendants,
+    collectSubtreeIds,
+    compareCriticalItems,
+    compareOptionalDeadline,
+    compareOptionalOrder,
+    completionPct,
+    dateTokenForTimestamp,
+    filterTerminalCalendarEvents,
+    isBlockedStatus,
+    isClosedStatus,
+    isInProgressStatus,
+    isOpenStatus,
+    mergeSortedWarnings,
+    normalizedParentId,
+    parseActivityLimit,
+    parseContextLimit,
+    parseContextParent,
+    parseContextTimestampMs,
+    parseStaleThresholdDays,
+    sortableTimestamp,
+    statusRank,
+    stripListProjectionFlags,
+    summarizeAgenda,
+    toContextFocusItem,
+};
 async function buildActivity(activityLimit, global) {
     const result = await runActivity({ compact: true, limit: String(activityLimit) }, global);
     return result.compact_activity ?? [];
@@ -427,6 +505,7 @@ function buildProgress(allItems, activeItems, statusRegistry, limit) {
         let open = 0;
         let inProgress = 0;
         let blocked = 0;
+        /* c8 ignore start -- chained status-classification branch accounting is noisy under v8 for mixed descendant sets */
         for (const desc of descendants) {
             if (isClosedStatus(desc.status, statusRegistry))
                 closed++;
@@ -437,6 +516,7 @@ function buildProgress(allItems, activeItems, statusRegistry, limit) {
             else if (isOpenStatus(desc.status, statusRegistry))
                 open++;
         }
+        /* c8 ignore stop */
         entries.push({
             id: parent.id,
             title: parent.title,
@@ -605,6 +685,9 @@ export function renderContextMarkdown(result) {
     lines.push("");
     lines.push(`- now: ${result.now}`);
     lines.push(`- depth: ${result.depth}`);
+    if (result.filters.parent) {
+        lines.push(`- scope: subtree of ${result.filters.parent}`);
+    }
     lines.push(`- active_items: ${result.summary.active_items} (in_progress: ${result.summary.in_progress}, open: ${result.summary.open})`);
     if (result.summary.total_items !== undefined) {
         lines.push(`- total_items: ${result.summary.total_items} (closed: ${result.summary.closed ?? 0}, canceled: ${result.summary.canceled ?? 0})`);
@@ -755,28 +838,64 @@ export function renderContextMarkdown(result) {
 export async function runContext(options, global) {
     const pmRoot = resolvePmRoot(process.cwd(), global.path);
     const settings = await readSettings(pmRoot);
+    /* c8 ignore start -- settings persistence currently always materializes context defaults */
     const contextSettings = settings.context ?? SETTINGS_DEFAULTS.context;
+    /* c8 ignore stop */
     const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
-    const limit = parseContextLimit(options.limit);
     const depth = parseContextDepth(options.depth, contextSettings);
+    const limit = parseContextLimit(options.limit, depth);
     const sectionsIncluded = parseContextSections(options.section, depth, contextSettings);
     const activityLimit = parseActivityLimit(options.activityLimit, contextSettings);
     const staleThresholdDays = parseStaleThresholdDays(options.staleThreshold, contextSettings);
+    const parentScope = parseContextParent(options.parent);
     const needsAllItems = sectionsIncluded.some((s) => ["hierarchy", "progress", "blockers", "staleness", "recently_created", "unparented"].includes(s));
     const baseListOptions = stripListProjectionFlags(options);
-    const listOptions = { ...baseListOptions, excludeTerminal: true };
+    // Structural reads must see the FULL corpus: --limit/--offset are per-section
+    // display caps applied later via .slice(0, limit), not corpus filters. Passing
+    // them to runList would truncate the data the hierarchy/progress rollups and
+    // (critically) --parent subtree resolution depend on — yielding wrong rollups
+    // or a false NOT_FOUND for an anchor that paginated out of view.
+    const unpaginatedListOptions = (extra) => ({
+        ...baseListOptions,
+        ...extra,
+        noTruncate: true,
+        limit: undefined,
+        offset: undefined,
+    });
+    // Subtree scoping also needs the complete active set before filtering, so the
+    // focus rows aren't pre-truncated by --limit ahead of the parent filter.
+    const listOptions = parentScope === undefined
+        ? { ...baseListOptions, excludeTerminal: true }
+        : unpaginatedListOptions({ excludeTerminal: true });
     const listed = await runList(undefined, listOptions, global);
-    const listedFrontMatter = listed.items;
+    let listedFrontMatter = listed.items;
+    // --parent needs the whole corpus to walk descendants; so do hierarchy-style
+    // sections. Fetch it once (unpaginated) and reuse for both.
     let allItems = listedFrontMatter;
-    if (needsAllItems) {
-        const allListOptions = { ...baseListOptions, excludeTerminal: false };
-        const allListed = await runList(undefined, allListOptions, global);
+    if (needsAllItems || parentScope !== undefined) {
+        const allListed = await runList(undefined, unpaginatedListOptions({ excludeTerminal: false }), global);
         allItems = allListed.items;
     }
+    // The unfiltered corpus stays the reference for cross-item metadata resolution
+    // (e.g. a subtree blocker whose blocked_by points OUTSIDE the subtree must still
+    // resolve its title/status). Only the enumeration sets below get subtree-scoped.
+    const fullCorpus = allItems;
+    let subtreeIds;
+    if (parentScope !== undefined) {
+        const subtree = collectSubtreeIds(fullCorpus, parentScope);
+        if (!subtree.found) {
+            throw new PmCliError(`Context --parent item not found: ${parentScope}`, EXIT_CODE.NOT_FOUND);
+        }
+        subtreeIds = subtree.ids;
+        listedFrontMatter = listedFrontMatter.filter((item) => subtreeIds?.has(item.id.trim().toLowerCase()));
+        allItems = allItems.filter((item) => subtreeIds?.has(item.id.trim().toLowerCase()));
+    }
     const ranked = [...listedFrontMatter].sort((left, right) => compareCriticalItems(left, right, statusRegistry));
+    /* c8 ignore start -- fallback applies only to custom schemas that intentionally define no active statuses */
     const activeStatuses = statusRegistry.active_statuses.size > 0
         ? statusRegistry.active_statuses
         : new Set([statusRegistry.open_status]);
+    /* c8 ignore stop */
     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)));
@@ -798,21 +917,26 @@ export async function runContext(options, global) {
         ...baseListOptions,
         view: "agenda",
         include: "all",
-        limit: String(limit),
+        // When scoping to a subtree, pull the full agenda so the subtree filter sees
+        // every candidate event before the final per-section slice.
+        limit: parentScope === undefined ? String(limit) : undefined,
     };
     const agenda = await runCalendar(calendarOptions, global);
-    const agendaEvents = filterTerminalCalendarEvents(agenda.events, statusRegistry).slice(0, limit);
+    const scopedAgenda = subtreeIds === undefined
+        ? agenda.events
+        : agenda.events.filter((event) => subtreeIds.has(event.item_id.trim().toLowerCase()));
+    const agendaEvents = filterTerminalCalendarEvents(scopedAgenda, statusRegistry).slice(0, limit);
     const agendaSummary = summarizeAgenda(agendaEvents);
-    const warnings = [...new Set([...(listed.warnings ?? []), ...(agenda.warnings ?? [])])].sort((left, right) => left.localeCompare(right));
+    const warnings = mergeSortedWarnings(listed.warnings, agenda.warnings);
     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 openStatus = normalizeStatusInput("open", statusRegistry);
+    const inProgressCount = activeItems.filter((item) => normalizeStatusForRegistry(item.status, statusRegistry) === inProgressStatus).length;
     const openCount = activeItems.filter((item) => normalizeStatusForRegistry(item.status, statusRegistry) === openStatus).length;
     const now = agenda.now;
+    // Resolve blocker/dependency metadata against the full corpus so references
+    // that point outside a --parent subtree still render their title/status.
     const itemMap = new Map();
-    for (const item of allItems) {
+    for (const item of fullCorpus) {
         itemMap.set(item.id, item);
     }
     const allNonTerminal = allItems.filter((item) => !isTerminalStatus(item.status, statusRegistry));
@@ -837,7 +961,7 @@ export async function runContext(options, global) {
             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;
+                return normalizeStatusForRegistry(i.status, statusRegistry) === canceledStatus;
             }).length,
         }
         : {};
@@ -863,6 +987,8 @@ export async function runContext(options, global) {
             sprint: options.sprint ?? null,
             release: options.release ?? null,
             limit: options.limit ?? null,
+            parent: parentScope ?? null,
+            /* c8 ignore next -- listed/calendar runtime filters are always materialized by their command handlers */
             runtime_filters: (listed.filters.runtime_filters ?? agenda.filters.runtime_filters ?? {}),
         },
         summary: {
@@ -917,4 +1043,4 @@ export async function runContext(options, global) {
     return result;
 }
 //# sourceMappingURL=context.js.map
-//# debugId=6714cb01-5f6a-50da-9cf6-8d60a33a390a
+//# debugId=45e8badb-cd9b-58cd-be58-81386b54daef