@unbrained/pm-cli 2026.8.21 → 2026.8.22

package/dist/sdk/lifecycle/update.js

@@ -4,7 +4,7 @@
  * Implements the pm update command surface and its agent-facing runtime behavior.
  */
 
-!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]="d024d9cf-81f8-5690-b8f4-03620e3e9bf8")}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]="7c1729f8-4a67-5746-a1bf-351f862ceb66")}catch(e){}}();
 import { assertInitializedTracker } from "../environment/tracker-preflight.js";
 import { COMMON_MUTATION_COMMAND_OPTION_KEYS, canonicalizeCommandOptionKey, commandOptionFlagLabel, resolveItemTypeRegistry, resolveCommandOptionPolicyState, resolveTypeDefinition, resolveTypeName, validateTypeOptions, normalizeItemId, toItemRecord, buildInvalidTypeError, assertParentReferenceIsNotSelf, normalizeParentReferenceValue, validateMissingParentReference, validateSprintOrReleaseValue, applyAcceptanceCriteriaMutations, applyTagRemovals, assertNoUnknownCsvKeys, createStdinTokenResolver, looksLikeGenericKeyValueEntry, mergeAdditiveTags, parseCsvKv, parseOptionalNonNegativeInteger, parseOptionalNumber, parseTags, splitAcceptanceCriteria, resolvePriority, normalizeStatusInput, isTerminalStatus, collectRuntimeUpdateFieldValues, resolveItemTypesFilePath, resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, describeAllowedTransitions, evaluateTransition, resolveTypeWorkflows, EXIT_CODE, PmCliError, stableValueEquals, resolveIsoOrRelative, getActiveExtensionRegistrations, collectRegisteredItemFieldNames, applyRegisteredItemFieldDefaultsAndValidation, parseRegisteredItemFieldAssignments, buildItemNotFoundError, listAllItemMetadataLight, locateItem, readLocatedItem, resolvePmRoot, readSettings, resolveAuthor, } from "../runtime-primitives.js";
 import { mutateItemWithHistoryContextResolver } from "../../core/store/item-store.js";
@@ -17,6 +17,9 @@ import { assertDependencyEdgesAllowed, assertDependencyTargetsResolvable, assert
 import { normalizeDependencySeedId, normalizeDependencySourceKind, } from "../dependency-provenance.js";
 import { resolveCanonicalRelationshipKind } from "../relationships.js";
 import { collectNewOrderingCycleWarnings } from "../graph/mutation-advisory.js";
+import { assertHierarchyMutationAllowed } from "../graph/hierarchy-integrity.js";
+import { resolveWorkspaceRelationshipKindRegistry } from "../graph/assembly.js";
+import { acquireHierarchyMutationLock } from "./hierarchy-mutation-lock.js";
 import { DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RISK_VALUES, } from "../../types/index.js";
 import { parseDocs, parseFiles, parseLogSeed, parseTests, requireStringOption, } from "./create.js";
 import { COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR, COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR, COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON, parseCommandUnsetTargets, resolveRuntimeUnsetFieldDefinition, } from "./shared-unset-fields.js";
@@ -355,6 +358,9 @@ function parseDependencyCreatedAt(value, currentIso) {
     if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
         return currentIso;
     }
+    return normalizeDependencyTimestamp(value);
+}
+function normalizeDependencyTimestamp(value) {
     const parsed = Date.parse(value);
     if (!Number.isFinite(parsed)) {
         throw new PmCliError(`Invalid dependency created_at timestamp "${value}"`, EXIT_CODE.USAGE);
@@ -377,7 +383,14 @@ const DEP_ADDITION_KEYS = [
     "source_kind",
 ];
 /** Allowed CSV/markdown keys for the `--dep-remove` selector (GH-258). */
-const DEP_REMOVE_KEYS = ["id", "kind", "type", "source_kind"];
+const DEP_REMOVE_KEYS = [
+    "id",
+    "kind",
+    "type",
+    "author",
+    "created_at",
+    "source_kind",
+];
 function looksLikeStructuredDependencyEntry(raw) {
     if (raw.startsWith("```") || raw.includes("\n")) {
         return true;
@@ -455,12 +468,18 @@ function parseDependencyRemovals(raw, prefix) {
             }
             const kindRaw = normalizeDependencyKindInput(parseOptionalDependencyString(kv.kind ?? kv.type));
             const sourceKind = normalizeDependencySourceKind(parseOptionalDependencyString(kv.source_kind));
+            const author = parseOptionalDependencyString(kv.author);
+            const createdAt = parseOptionalDependencyString(kv.created_at);
             return {
                 id: normalizeDependencySeedId(idRaw, prefix, sourceKind),
                 kind: kindRaw
                     ? ensureEnum(kindRaw, DEPENDENCY_KIND_VALUES, "dependency kind")
                     : undefined,
                 source_kind: sourceKind,
+                author,
+                created_at: createdAt
+                    ? normalizeDependencyTimestamp(createdAt)
+                    : undefined,
             };
         }
         if (trimmed.toLowerCase() === "undefined") {
@@ -473,7 +492,24 @@ function parseDependencyRemovals(raw, prefix) {
 }
 function dependencyKey(value) {
     const sourceKind = value.source_kind?.trim().toLowerCase() ?? "";
-    return `${value.id.trim().toLowerCase()}::${value.kind}::${sourceKind}`;
+    return [value.id.trim().toLowerCase(), value.kind, sourceKind].join("\u0000");
+}
+/** Return the complete normalized identity of one stored dependency row. */
+function storedDependencyIdentityKey(value) {
+    const sourceKind = value.source_kind?.trim().toLowerCase() ?? "";
+    const author = value.author?.trim().toLowerCase() ?? "";
+    const rawCreatedAt = value.created_at?.trim() ?? "";
+    const parsedCreatedAt = Date.parse(rawCreatedAt);
+    const createdAt = Number.isFinite(parsedCreatedAt)
+        ? new Date(parsedCreatedAt).toISOString()
+        : rawCreatedAt;
+    return [
+        value.id.trim().toLowerCase(),
+        value.kind,
+        sourceKind,
+        author,
+        createdAt,
+    ].join("\u0000");
 }
 // pm-kyd6: `--blocked-by` writes the `blocked_by` scalar, but the dependency
 // graph (`pm deps`) is built only from the `dependencies` array. Mirror the
@@ -568,6 +604,17 @@ function matchesDependencySelector(value, selector) {
             selector.source_kind.trim().toLowerCase()) {
         return false;
     }
+    if (selector.author !== undefined &&
+        value.author?.trim().toLowerCase() !== selector.author.trim().toLowerCase()) {
+        return false;
+    }
+    if (selector.created_at !== undefined &&
+        (value.created_at === undefined ||
+            !Number.isFinite(Date.parse(value.created_at)) ||
+            new Date(Date.parse(value.created_at)).toISOString() !==
+                selector.created_at)) {
+        return false;
+    }
     return true;
 }
 function ensurePriority(raw) {
@@ -1082,6 +1129,19 @@ async function buildNoopUpdateResult(params) {
         warnings: ["noop_no_update_fields"],
     };
 }
+async function loadUpdateRelationshipGraph(params) {
+    if (!params.fieldFlags.dep &&
+        !params.fieldFlags.blockedBy &&
+        !params.fieldFlags.parent &&
+        !params.clearedMetadataKeys.has("parent"))
+        return undefined;
+    return listAllItemMetadataLight(params.pmRoot, params.settings.item_format, params.typeToFolder, undefined, params.settings.schema);
+}
+function assertUpdateHierarchyIntegrity(params) {
+    if (!params.before)
+        return;
+    assertHierarchyMutationAllowed(params.before, params.before.map((item) => item.id === params.document.metadata.id ? params.document.metadata : item), params.document.metadata.id, (status) => isTerminalStatus(status, params.statusRegistry), resolveWorkspaceRelationshipKindRegistry());
+}
 async function assertUpdateTrackerInitialized(pmRoot) {
     await assertInitializedTracker(pmRoot);
 }
@@ -1315,16 +1375,16 @@ function applyTypeOptionMutation(document, context, activeTypeName, changedField
 /** Collapse duplicate rows only for identities explicitly touched by this mutation. */
 function normalizeTouchedDependencyIdentities(current, additions) {
     const touchedKeys = new Set(additions.map((entry) => dependencyKey(entry)));
-    const retainedTouchedKeys = new Set();
+    const retainedStoredIdentities = new Set();
     return current.filter((entry) => {
-        const key = dependencyKey(entry);
-        if (!touchedKeys.has(key)) {
+        if (!touchedKeys.has(dependencyKey(entry))) {
             return true;
         }
-        if (retainedTouchedKeys.has(key)) {
+        const storedIdentity = storedDependencyIdentityKey(entry);
+        if (retainedStoredIdentities.has(storedIdentity)) {
             return false;
         }
-        retainedTouchedKeys.add(key);
+        retainedStoredIdentities.add(storedIdentity);
         return true;
     });
 }
@@ -1342,11 +1402,13 @@ function assertDependencyRemovalSelectorsMatch(current, selectors, itemId) {
             id: entry.id,
             kind: entry.kind,
             source_kind: entry.source_kind,
+            author: entry.author,
+            created_at: entry.created_at,
         })),
         why: "Failing on a zero-match selector prevents a mistyped dependency removal from being reported as successful.",
         nextSteps: [
             `Inspect the current item with: pm get ${itemId} --full`,
-            "Retry --dep-remove with the exact id, kind, and optional source_kind shown in dependencies.",
+            "Retry --dep-remove with the exact id plus any kind, source_kind, author, or created_at selectors needed to identify one stored row.",
         ],
     });
 }
@@ -1857,82 +1919,108 @@ async function runUpdateWithContext(id, options, global, execution = {}) {
         return routedClose;
     }
     assertMatchingOrderRank(options);
-    let graphBeforeUpdate = fieldFlags.dep || fieldFlags.depRemove || fieldFlags.blockedBy
-        ? await listAllItemMetadataLight(pmRoot, settings.item_format, typeRegistry.type_to_folder, undefined, settings.schema)
-        : undefined;
-    let lifecycleTransition;
-    let recurrenceHistoryContext;
-    const result = await mutateItemWithHistoryContextResolver({
+    const relationshipRegistry = resolveWorkspaceRelationshipKindRegistry();
+    const hierarchyMutationRequired = (fieldFlags.parent && !clearItemMetadataKeys.has("parent")) ||
+        dependencyUpdates.additions.some((dependency) => relationshipRegistry.resolve(dependency.kind)?.hierarchy);
+    const releaseHierarchyMutationLock = await acquireHierarchyMutationLock({
         pmRoot,
-        settings,
-        typeToFolder: typeRegistry.type_to_folder,
-        id,
-        op: resolveUpdateHistoryOperation(options, execution),
         author,
-        message: options.message,
-        resolveHistoryContext: () => recurrenceHistoryContext,
-        force: options.force,
-        bypassAssigneeConflict: options.ownershipMetadataBypass === true ||
-            options.ownershipDependencyBypass === true,
-        extensionFieldNames,
-        skipNoop: true,
-        mutate(document) {
-            lifecycleTransition = prepareRecurrenceTransition({
-                document,
-                recurrenceReason: execution.recurrenceReason,
-                requestedStatus: options.status,
-                statusRegistry,
-            });
-            recurrenceHistoryContext = lifecycleTransition
-                ? { recurrence: lifecycleTransition }
-                : undefined;
-            graphBeforeUpdate = graphBeforeUpdate?.map((item) => item.id === document.metadata.id
-                ? structuredClone(document.metadata)
-                : item);
-            return mutateUpdateDocument(document, {
-                options,
-                settings,
-                typeRegistry,
-                statusRegistry,
-                runtimeFieldRegistry,
-                extensionRegistrations,
-                extensionFieldNames,
-                clearItemMetadataKeys,
-                dependencyUpdates,
-                dependencyRemovals,
-                commentUpdates,
-                noteUpdates,
-                learningUpdates,
-                fileUpdates,
-                testUpdates,
-                docUpdates,
-                resolvedParentValue: parentReference.resolvedParentValue,
-                resolvedBlockedByDependencyId,
-                runtimeFieldUpdates,
-                nowValue,
-                nowIso,
-                author,
-                pmRoot,
-            });
-        },
+        ttlSeconds: settings.locks.ttl_seconds,
+        waitMs: settings.locks.wait_ms,
+        required: hierarchyMutationRequired,
     });
-    const orderingCycleWarnings = graphBeforeUpdate
-        ? collectNewOrderingCycleWarnings(graphBeforeUpdate, graphBeforeUpdate.map((item) => item.id === result.item.id ? result.item : item), result.item.id)
-        : [];
-    return {
-        item: toItemRecord(result.item),
-        changed_fields: result.changedFields,
-        warnings: [
-            ...workflowTransitionWarnings,
-            ...parentReferenceWarnings,
-            ...dependencyTargetWarnings,
-            ...orderingCycleWarnings,
-            ...result.warnings,
-        ],
-        ...(lifecycleTransition === undefined
-            ? {}
-            : { lifecycle_transition: lifecycleTransition }),
-    };
+    try {
+        let graphBeforeUpdate = await loadUpdateRelationshipGraph({
+            fieldFlags,
+            clearedMetadataKeys: clearItemMetadataKeys,
+            pmRoot,
+            settings,
+            typeToFolder: typeRegistry.type_to_folder,
+        });
+        let lifecycleTransition;
+        let recurrenceHistoryContext;
+        const result = await mutateItemWithHistoryContextResolver({
+            pmRoot,
+            settings,
+            typeToFolder: typeRegistry.type_to_folder,
+            id,
+            op: resolveUpdateHistoryOperation(options, execution),
+            author,
+            message: options.message,
+            resolveHistoryContext: () => recurrenceHistoryContext,
+            force: options.force,
+            bypassAssigneeConflict: options.ownershipMetadataBypass === true ||
+                options.ownershipDependencyBypass === true,
+            extensionFieldNames,
+            skipNoop: true,
+            mutate(document) {
+                lifecycleTransition = prepareRecurrenceTransition({
+                    document,
+                    recurrenceReason: execution.recurrenceReason,
+                    requestedStatus: options.status,
+                    statusRegistry,
+                });
+                recurrenceHistoryContext = lifecycleTransition
+                    ? { recurrence: lifecycleTransition }
+                    : undefined;
+                graphBeforeUpdate = graphBeforeUpdate?.map((item) => item.id === document.metadata.id
+                    ? structuredClone(document.metadata)
+                    : item);
+                const mutation = mutateUpdateDocument(document, {
+                    options,
+                    settings,
+                    typeRegistry,
+                    statusRegistry,
+                    runtimeFieldRegistry,
+                    extensionRegistrations,
+                    extensionFieldNames,
+                    clearItemMetadataKeys,
+                    dependencyUpdates,
+                    dependencyRemovals,
+                    commentUpdates,
+                    noteUpdates,
+                    learningUpdates,
+                    fileUpdates,
+                    testUpdates,
+                    docUpdates,
+                    resolvedParentValue: parentReference.resolvedParentValue,
+                    resolvedBlockedByDependencyId,
+                    runtimeFieldUpdates,
+                    nowValue,
+                    nowIso,
+                    author,
+                    pmRoot,
+                });
+                assertUpdateHierarchyIntegrity({
+                    before: graphBeforeUpdate,
+                    document,
+                    statusRegistry,
+                });
+                return mutation;
+            },
+        });
+        await releaseHierarchyMutationLock();
+        const orderingCycleWarnings = graphBeforeUpdate
+            ? collectNewOrderingCycleWarnings(graphBeforeUpdate, graphBeforeUpdate.map((item) => item.id === result.item.id ? result.item : item), result.item.id)
+            : [];
+        return {
+            item: toItemRecord(result.item),
+            changed_fields: result.changedFields,
+            warnings: [
+                ...workflowTransitionWarnings,
+                ...parentReferenceWarnings,
+                ...dependencyTargetWarnings,
+                ...orderingCycleWarnings,
+                ...result.warnings,
+            ],
+            ...(lifecycleTransition === undefined
+                ? {}
+                : { lifecycle_transition: lifecycleTransition }),
+        };
+    }
+    finally {
+        await releaseHierarchyMutationLock();
+    }
 }
 /** Resolve the immutable operation name for ordinary, bypass, and recurrence updates. */
 function resolveUpdateHistoryOperation(options, execution) {
@@ -2021,4 +2109,4 @@ export const _testOnlyUpdateCommand = {
     resolveRuntimeUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "update", registry),
 };
 //# sourceMappingURL=update.js.map
-//# debugId=d024d9cf-81f8-5690-b8f4-03620e3e9bf8
+//# debugId=7c1729f8-4a67-5746-a1bf-351f862ceb66

package/dist/sdk/query/complete-list.d.ts

@@ -6,7 +6,7 @@
 import type { PmReadOutputReceipt } from "../read-output-contracts.js";
 import type { ListFullResult, ListOptions } from "./list.js";
 /** Stable reasons a purported whole-workspace list cannot be trusted. */
-export declare const PM_COMPLETE_LIST_FINDING_CODES: readonly ["invalid_envelope", "source_incomplete", "source_unchecked", "filtered_corpus", "terminal_items_excluded", "strict_read_unproven", "page_incomplete", "count_mismatch", "projection_incomplete", "field_omission", "budget_compaction", "budget_omission", "session_projection", "invalid_item_id", "duplicate_item_id"];
+export declare const PM_COMPLETE_LIST_FINDING_CODES: readonly ["invalid_envelope", "source_incomplete", "source_unchecked", "filtered_corpus", "terminal_items_excluded", "strict_read_unproven", "page_incomplete", "count_mismatch", "projection_incomplete", "field_omission", "omission_receipt_missing", "omission_receipt_invalid", "read_output_missing", "read_output_invalid", "read_output_dimensions_incomplete", "budget_compaction", "budget_omission", "session_projection", "invalid_item_id", "duplicate_item_id"];
 /** Machine-readable reason a complete-list candidate failed certification. */
 export type PmCompleteListFindingCode = (typeof PM_COMPLETE_LIST_FINDING_CODES)[number];
 /** One independently actionable complete-list contract violation. */
@@ -39,8 +39,8 @@ export interface PmCompleteListCertificate {
 export interface PmCompleteListResult extends ListFullResult {
     /** Exact proof that the returned rows represent the full tracker corpus. */
     complete_list: PmCompleteListCertificate;
-    /** Universal read receipt when the runtime attached one. */
-    read_output?: PmReadOutputReceipt;
+    /** Mandatory universal read receipt proving unbounded, uncompacted delivery. */
+    read_output: PmReadOutputReceipt;
 }
 /** Inspection report returned without throwing for policy and UI consumers. */
 export interface PmCompleteListInspection {

package/dist/sdk/query/complete-list.js

@@ -1,6 +1,6 @@
 /** Stable reasons a purported whole-workspace list cannot be trusted. */
 
-!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]="cc342d27-aa2d-5e84-8441-46a35c42dc00")}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]="c14a67b4-102d-5219-b2b3-15d39da36627")}catch(e){}}();
 export const PM_COMPLETE_LIST_FINDING_CODES = [
     "invalid_envelope",
     "source_incomplete",
@@ -12,6 +12,11 @@ export const PM_COMPLETE_LIST_FINDING_CODES = [
     "count_mismatch",
     "projection_incomplete",
     "field_omission",
+    "omission_receipt_missing",
+    "omission_receipt_invalid",
+    "read_output_missing",
+    "read_output_invalid",
+    "read_output_dimensions_incomplete",
     "budget_compaction",
     "budget_omission",
     "session_projection",
@@ -31,7 +36,7 @@ export class PmCompleteListValidationError extends Error {
             contract: "complete_list",
             findings,
             recovery: {
-                suggested_retry: "pm list-all --full --strict-read --no-truncate --output-budget unbounded --json",
+                suggested_retry: "pm list --all --output-include full --strict-read --no-truncate --output-budget unbounded --output-limit unbounded --json",
                 sdk: "await client.listAllComplete()",
             },
         };
@@ -67,6 +72,17 @@ function inspectSourceScope(candidate, findings) {
         : {};
     addFinding(findings, completeness.status === "partial", "source_incomplete", "The source scan reported unreadable tracker artifacts.");
     addFinding(findings, completeness.status !== "complete" && completeness.status !== "partial", "source_unchecked", "The source scan did not prove completeness.");
+    const unreadableItemCount = completeness.unreadable_item_count;
+    const unreadableDirectoryCount = completeness.unreadable_directory_count;
+    addFinding(findings, completeness.status === "complete" &&
+        (unreadableItemCount !== 0 || unreadableDirectoryCount !== 0) &&
+        Number.isSafeInteger(unreadableItemCount) &&
+        Number.isSafeInteger(unreadableDirectoryCount), "source_incomplete", "The source scan reports unreadable tracker artifacts despite a complete status.");
+    addFinding(findings, completeness.status === "complete" &&
+        (!Number.isSafeInteger(unreadableItemCount) ||
+            !Number.isSafeInteger(unreadableDirectoryCount) ||
+            Number(unreadableItemCount) < 0 ||
+            Number(unreadableDirectoryCount) < 0), "source_unchecked", "The source scan did not report safe non-negative unreadable counts.");
     const filters = isRecord(candidate.filters) ? candidate.filters : {};
     const runtimeFilters = isRecord(filters.runtime_filters)
         ? filters.runtime_filters
@@ -100,13 +116,40 @@ function inspectEnvelopeShape(candidate, filters, findings) {
     const omissionReceipt = isRecord(candidate.omission_receipt)
         ? candidate.omission_receipt
         : undefined;
+    addFinding(findings, omissionReceipt === undefined, "omission_receipt_missing", "The result carries no field-omission receipt.");
+    addFinding(findings, omissionReceipt !== undefined &&
+        (omissionReceipt.has_omissions !== false ||
+            omissionReceipt.omitted_field_group_count !== 0 ||
+            !Number.isSafeInteger(omissionReceipt.omitted_field_group_count) ||
+            !Array.isArray(omissionReceipt.omitted_field_groups) ||
+            omissionReceipt.omitted_field_groups.length !== 0), "omission_receipt_invalid", "The field-omission receipt is malformed or contradicts its no-omission claim.");
     addFinding(findings, omissionReceipt?.has_omissions === true, "field_omission", "The omission receipt reports withheld field groups.");
 }
+/** Return whether a universal read receipt cannot prove an intact list result. */
+function isInvalidCompleteListReadOutput(readOutput) {
+    return (readOutput.contract_version !== 1 ||
+        readOutput.command !== "list" ||
+        readOutput.within_budget !== true ||
+        readOutput.strings_compacted !== false ||
+        readOutput.rows_compacted !== false ||
+        readOutput.result_omitted !== false);
+}
+/** Return whether the receipt proves every dimension required for an unbounded full read. */
+function hasCompleteListReadOutputDimensions(readOutput) {
+    if (!Array.isArray(readOutput.requested_dimensions))
+        return false;
+    const requestedDimensions = new Set(readOutput.requested_dimensions);
+    return ["include", "amount", "cost"].every((dimension) => requestedDimensions.has(dimension));
+}
 /** Append universal-output and cross-call-session findings. */
 function inspectOutputScope(candidate, findings) {
     const readOutput = isRecord(candidate.read_output)
         ? candidate.read_output
         : undefined;
+    addFinding(findings, readOutput === undefined, "read_output_missing", "The result carries no universal read-output receipt.");
+    addFinding(findings, readOutput !== undefined && isInvalidCompleteListReadOutput(readOutput), "read_output_invalid", "The universal read-output receipt does not prove an intact list result.");
+    addFinding(findings, readOutput !== undefined &&
+        !hasCompleteListReadOutputDimensions(readOutput), "read_output_dimensions_incomplete", "The universal read-output receipt does not prove full, unbounded include, amount, and cost dimensions.");
     addFinding(findings, readOutput?.strings_compacted === true ||
         readOutput?.rows_compacted === true ||
         candidate.output_budget_truncation !== undefined, "budget_compaction", "Universal output shaping compacted the result.");
@@ -170,4 +213,4 @@ export function assertCompleteListResult(candidate) {
     certifyCompleteListResult(candidate);
 }
 //# sourceMappingURL=complete-list.js.map
-//# debugId=cc342d27-aa2d-5e84-8441-46a35c42dc00
+//# debugId=c14a67b4-102d-5219-b2b3-15d39da36627

package/dist/sdk/query/list.d.ts

@@ -5,6 +5,7 @@ import { type RuntimeStatusRegistry } from "../../core/schema/runtime-schema.js"
 import type { GlobalOptions } from "../../core/shared/command-types.js";
 import type { ItemMetadata, ItemStatus } from "../../types/index.js";
 import type { SharedItemFilterOptions } from "./item-filter-options.js";
+import { type HierarchyRelationIndexes } from "../graph/hierarchy-integrity.js";
 import { type ListCommandName, type ListProjectionMode } from "./projection-contracts.js";
 export { BRIEF_LIST_FIELDS, DEFAULT_COMPACT_LIST_FIELDS, LIST_COMMAND_DEFAULT_PROJECTIONS, listListProjectionFields, type ListCommandName, type ListProjectionMode, } from "./projection-contracts.js";
 /** Documents the list options payload exchanged by command, SDK, and package integrations. */
@@ -236,10 +237,10 @@ declare function normalizeProjectionField(field: string): string;
 declare function parseSortField(raw: string | undefined): ListSortField | undefined;
 declare function parseSortOrder(raw: string | undefined): ListSortOrder | undefined;
 declare function parseAssigneeFilter(raw: string | undefined): "assigned" | "unassigned" | undefined;
-declare function applyFilters(items: ListedItem[], status: ItemStatus[] | undefined, options: ListOptions, typeRegistry: ItemTypeRegistry, statusRegistry: RuntimeStatusRegistry, runtimeFieldFilters: Record<string, unknown>): ListedItem[];
+declare function applyFilters(items: ListedItem[], status: ItemStatus[] | undefined, options: ListOptions, typeRegistry: ItemTypeRegistry, statusRegistry: RuntimeStatusRegistry, runtimeFieldFilters: Record<string, unknown>, parentsByChild?: HierarchyRelationIndexes["parents_by_child"]): ListedItem[];
 declare function trimNonEmpty(value: string | undefined): string | undefined;
-declare function withTreeMetadata(item: ListedItem, depth: number, childCount: number): ListTreeItem;
-declare function orderItemsAsTree(sortedItems: ListedItem[], parentRoot: string | undefined, maxDepth: number | undefined): ListedItem[];
+declare function withTreeMetadata(item: ListedItem, depth: number, childCount: number, parentId?: string): ListTreeItem;
+declare function orderItemsAsTree(sortedItems: ListedItem[], parentRoot: string | undefined, maxDepth: number | undefined, hierarchyIndexes?: HierarchyRelationIndexes, completeItems?: readonly ListedItem[]): ListedItem[];
 declare function compareNullableString(left: string | null, right: string | null): number;
 declare function compareNullableTimestamp(left: string | null, right: string | null): number;
 declare function compareBySortField(left: ListedItem, right: ListedItem, field: ListSortField): number;