@unbrained/pm-cli 2026.8.21 → 2026.8.23

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]="c88f01be-6abe-5fa2-9792-3f54e61bb282")}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,8 +17,12 @@ 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 { attachLinkedTestMutationProvenance } from "../test/trust.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";
 const UPDATE_UNSET_FIELD_DEFINITIONS = [
     ...COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
@@ -355,6 +359,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 +384,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 +469,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 +493,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
@@ -554,7 +591,7 @@ function docKey(value) {
     return `${value.path}::${value.scope}`;
 }
 function testKey(value) {
-    return `${value.command}::${value.path ?? ""}::${value.scope}::${value.pm_context_mode ?? ""}`;
+    return `${value.command}::${value.path ?? ""}::${value.scope}::${value.pm_context_mode ?? ""}::${value.workspace_context_mode ?? ""}`;
 }
 function matchesDependencySelector(value, selector) {
     if (value.id.trim().toLowerCase() !== selector.id.trim().toLowerCase()) {
@@ -568,6 +605,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 +1130,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 +1376,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 +1403,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.",
         ],
     });
 }
@@ -1809,6 +1872,7 @@ async function runUpdateWithContext(id, options, global, execution = {}) {
     const learningUpdates = parseLogSeed("--learning", options.learning, nowIso, author);
     const fileUpdates = parseFiles(options.file);
     const testUpdates = parseTests(options.test);
+    testUpdates.values = await attachLinkedTestMutationProvenance(testUpdates.values, author, nowIso);
     const docUpdates = parseDocs(options.doc);
     const workflowTransitionWarnings = [];
     const parentReference = await resolveParentReferenceForUpdate({
@@ -1857,82 +1921,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 +2111,4 @@ export const _testOnlyUpdateCommand = {
     resolveRuntimeUnsetDefinition: (token, registry) => resolveRuntimeUnsetFieldDefinition(token, "update", registry),
 };
 //# sourceMappingURL=update.js.map
-//# debugId=d024d9cf-81f8-5690-b8f4-03620e3e9bf8
+//# debugId=c88f01be-6abe-5fa2-9792-3f54e61bb282

package/dist/sdk/merge/three-way.js

@@ -9,7 +9,7 @@
  * definition for multi-branch agent workflows.
  */
 
-!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]="3c9d6924-ae7c-57c3-a346-1e2189c532fa")}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]="393f6460-bf8b-5479-8e3e-cac6f2680823")}catch(e){}}();
 import { historyEntriesToRaw, reanchorHistoryEntries, } from "../../core/history/replay.js";
 import { canonicalDocument, parseItemDocument, serializeItemDocument, } from "../../core/item/item-format.js";
 import { EXIT_CODE } from "../../core/shared/constants.js";
@@ -318,6 +318,58 @@ function unionCollection(base, ours, theirs) {
     }
     return merged;
 }
+function linkedTestDefinitionIdentity(value) {
+    /* c8 ignore start -- canonical item parsing normalizes linked-test entries to object records */
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return stableStringify(value);
+    }
+    /* c8 ignore stop */
+    const { provenance: _provenance, ...definition } = value;
+    return stableStringify(definition);
+}
+function markMergedLinkedTest(value) {
+    /* c8 ignore start -- canonical item parsing normalizes linked-test entries to object records */
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return value;
+    }
+    /* c8 ignore stop */
+    const test = value;
+    if (!test.provenance) {
+        return {
+            ...test,
+            // Legacy entries contributed by another branch must not regain implicit
+            // local trust. This incomplete merge marker is preserved by normalization
+            // and refused until an operator acknowledges it in the receiving clone.
+            provenance: { source_kind: "merge_union" },
+        };
+    }
+    return {
+        ...test,
+        provenance: {
+            ...test.provenance,
+            source_kind: "merge_union",
+        },
+    };
+}
+function unionLinkedTests(base, ours, theirs) {
+    const toEntries = (value) => Array.isArray(value) ? value : [];
+    const baseIds = new Set(toEntries(base).map(linkedTestDefinitionIdentity));
+    const oursEntries = toEntries(ours);
+    const oursIds = new Set(oursEntries.map(linkedTestDefinitionIdentity));
+    const theirsEntries = toEntries(theirs);
+    const theirsIds = new Set(theirsEntries.map(linkedTestDefinitionIdentity));
+    const merged = oursEntries.filter((entry) => {
+        const identity = linkedTestDefinitionIdentity(entry);
+        return !baseIds.has(identity) || theirsIds.has(identity);
+    });
+    for (const entry of theirsEntries) {
+        const identity = linkedTestDefinitionIdentity(entry);
+        if (!oursIds.has(identity) && !baseIds.has(identity)) {
+            merged.push(markMergedLinkedTest(entry));
+        }
+    }
+    return merged;
+}
 function latestTimestamp(ours, theirs) {
     return compareTimestampStrings(String(ours), String(theirs)) >= 0
         ? ours
@@ -362,6 +414,40 @@ function parseItemMergeSide(raw, label, options) {
         throw new PmCliError(`Item merge input (${label}) is not a readable item document: ${String(error)}`, EXIT_CODE.GENERIC_FAILURE);
     }
 }
+/** Merge one collection field and report whether the field was handled. */
+function mergeItemUnionField(params) {
+    if (!params.unionFieldSet.has(params.field))
+        return false;
+    const union = params.field === "tests"
+        ? unionLinkedTests(params.baseValue, params.oursValue, params.theirsValue)
+        : unionCollection(params.baseValue, params.oursValue, params.theirsValue);
+    params.accumulator.merged[params.field] = union;
+    if (!jsonEquals(union, params.oursValue)) {
+        params.accumulator.unionFields.push(params.field);
+    }
+    return true;
+}
+/** Merge one scalar field while preserving conflict evidence. */
+function mergeItemScalarField(params) {
+    const outcome = mergeItemScalarThreeWay(params.baseValue, params.oursValue, params.theirsValue, params.preferred, params.conflictResolution);
+    if (outcome.value !== undefined) {
+        params.accumulator.merged[params.field] = outcome.value;
+    }
+    if (outcome.conflict) {
+        params.accumulator.conflictFields.push(params.field);
+        params.accumulator.conflictDecisions.push({
+            field: params.field,
+            base: params.baseValue,
+            ours: params.oursValue,
+            theirs: params.theirsValue,
+            retained: outcome.value,
+            discarded: outcome.from_theirs ? params.oursValue : params.theirsValue,
+        });
+    }
+    else if (outcome.from_theirs) {
+        params.accumulator.fieldsFromTheirs.push(params.field);
+    }
+}
 function mergeItemMetadataRecords(baseRecord, oursRecord, theirsRecord, preferred, conflictResolution) {
     const unionFieldSet = new Set(ITEM_UNION_COLLECTION_FIELDS);
     const latestFieldSet = new Set(ITEM_LATEST_TIMESTAMP_FIELDS);
@@ -379,39 +465,32 @@ function mergeItemMetadataRecords(baseRecord, oursRecord, theirsRecord, preferre
         const baseValue = baseRecord[field];
         const oursValue = oursRecord[field];
         const theirsValue = theirsRecord[field];
-        if (unionFieldSet.has(field)) {
-            const union = unionCollection(baseValue, oursValue, theirsValue);
+        if (mergeItemUnionField({
+            field,
+            baseValue,
+            oursValue,
+            theirsValue,
+            unionFieldSet,
+            accumulator,
+        })) {
             // `fieldNames` is derived from both records' own keys, so a collection
             // reached here is declared by at least one side. Preserve even an empty
             // result (`tags` is required) so serialization never drops it.
-            accumulator.merged[field] = union;
-            if (!jsonEquals(union, oursValue)) {
-                accumulator.unionFields.push(field);
-            }
             continue;
         }
         if (latestFieldSet.has(field)) {
             accumulator.merged[field] = latestTimestamp(oursValue, theirsValue);
             continue;
         }
-        const outcome = mergeItemScalarThreeWay(baseValue, oursValue, theirsValue, preferred, conflictResolution);
-        if (outcome.value !== undefined) {
-            accumulator.merged[field] = outcome.value;
-        }
-        if (outcome.conflict) {
-            accumulator.conflictFields.push(field);
-            accumulator.conflictDecisions.push({
-                field,
-                base: baseValue,
-                ours: oursValue,
-                theirs: theirsValue,
-                retained: outcome.value,
-                discarded: outcome.from_theirs ? oursValue : theirsValue,
-            });
-        }
-        else if (outcome.from_theirs) {
-            accumulator.fieldsFromTheirs.push(field);
-        }
+        mergeItemScalarField({
+            field,
+            baseValue,
+            oursValue,
+            theirsValue,
+            preferred,
+            conflictResolution,
+            accumulator,
+        });
     }
     return accumulator;
 }
@@ -625,4 +704,4 @@ export function mergeJsonDocuments(baseRaw, oursRaw, theirsRaw, options = {}) {
     };
 }
 //# sourceMappingURL=three-way.js.map
-//# debugId=3c9d6924-ae7c-57c3-a346-1e2189c532fa
+//# debugId=393f6460-bf8b-5479-8e3e-cac6f2680823

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