@unbrained/pm-cli 2026.8.13 → 2026.8.14

package/dist/sdk/graph/assembly.d.ts

@@ -77,6 +77,19 @@ export interface DuplicateDependencyRow {
     /** Whether the holder is terminal and the duplication is historical debt. */
     legacy_terminal: boolean;
 }
+/** One holder whose scalar blocker and structured ordering row assert opposite precedence. */
+export interface OrderingStorageContradiction {
+    /** Item storing both contradictory representations. */
+    holder_id: string;
+    /** Target named by both the scalar blocker and structured dependency row. */
+    target_id: string;
+    /** Structured ordering kind that places the holder before the target. */
+    dependency_kind: string;
+    /** Current lifecycle status of the holder. */
+    holder_status: ItemStatus;
+    /** Whether the holder is terminal and the contradiction is historical debt. */
+    legacy_terminal: boolean;
+}
 /**
  * Collect raw stored dependency rows whose exact identity — holder, kind, and
  * case-insensitive target — appears more than once on one item. Graph
@@ -85,6 +98,14 @@ export interface DuplicateDependencyRow {
  * only surface that reports the storage-layer defect.
  */
 export declare function collectDuplicateDependencyRows(items: readonly DependencyReferenceHolder[], isTerminal?: (status: ItemStatus) => boolean): DuplicateDependencyRow[];
+/**
+ * Collect storage rows where `blocked_by: target` places the target before the
+ * holder while a same-target structured ordering dependency places the holder
+ * before the target. The contradictory rows form an artificial two-node cycle
+ * after graph assembly, so this pre-assembly evidence identifies the exact row
+ * to remove instead of reporting only strongly connected component members.
+ */
+export declare function collectOrderingStorageContradictions(items: readonly DependencyReferenceHolder[], isTerminal?: (status: ItemStatus) => boolean, registry?: RelationshipKindRegistry): OrderingStorageContradiction[];
 /**
  * Classify missing hierarchy and dependency targets without mutating their holders.
  *
@@ -127,6 +148,8 @@ export interface WorkspaceRelationshipAssembly {
     dangling: DanglingDependencyReferenceSummary;
     /** Raw same-identity duplicated dependency rows found before graph dedup. */
     duplicateRows: DuplicateDependencyRow[];
+    /** Scalar-versus-structured ordering contradictions found before graph normalization. */
+    orderingContradictions?: OrderingStorageContradiction[];
     /** Raw legacy alias rows grouped by accepted spelling before graph canonicalization. */
     legacyAliasCounts: Record<string, number>;
 }

package/dist/sdk/graph/assembly.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]="62ec8e0e-658e-5a32-b458-439d5ffd1229")}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]="a6fc5da1-b7d1-5b3c-8033-cecccc7861c3")}catch(e){}}();
 import { getActiveExtensionRegistrations } from "../../core/extensions/index.js";
 import { RelationshipGraph, createRelationshipKindRegistry, } from "../relationships.js";
 import { isExternalDependencySourceKind } from "../dependency-provenance.js";
@@ -104,6 +104,57 @@ export function collectDuplicateDependencyRows(items, isTerminal = (status) => s
         return compareCaseFoldedText(left.kind, right.kind);
     });
 }
+/** Decode one dependency row only when it contradicts the holder's scalar blocker. */
+function decodeOrderingStorageContradiction(item, blocker, dependency, isTerminal, registry) {
+    if (typeof dependency !== "object" || dependency === null)
+        return undefined;
+    const target = normalizeDependencyReferenceTarget(dependency.id);
+    if (!target || target.toLowerCase() !== blocker.toLowerCase())
+        return undefined;
+    const definition = registry.resolve(typeof dependency.kind === "string" ? dependency.kind : "related");
+    if (definition?.ordering !== true ||
+        (definition.precedence ?? "source_before_target") !== "source_before_target")
+        return undefined;
+    return {
+        holder_id: item.id.trim(),
+        target_id: target,
+        dependency_kind: definition.kind,
+        holder_status: item.status,
+        legacy_terminal: isTerminal(item.status),
+    };
+}
+/**
+ * Collect storage rows where `blocked_by: target` places the target before the
+ * holder while a same-target structured ordering dependency places the holder
+ * before the target. The contradictory rows form an artificial two-node cycle
+ * after graph assembly, so this pre-assembly evidence identifies the exact row
+ * to remove instead of reporting only strongly connected component members.
+ */
+export function collectOrderingStorageContradictions(items, isTerminal = (status) => status === "closed" || status === "canceled", registry = resolveWorkspaceRelationshipKindRegistry()) {
+    const contradictions = new Map();
+    for (const item of items) {
+        if (typeof item?.id !== "string" || item.id.trim().length === 0)
+            continue;
+        const blocker = normalizeDependencyReferenceTarget(item.blocked_by);
+        if (!blocker)
+            continue;
+        for (const dependency of item.dependencies ?? []) {
+            const row = decodeOrderingStorageContradiction(item, blocker, dependency, isTerminal, registry);
+            if (!row)
+                continue;
+            contradictions.set(`${row.holder_id.toLowerCase()}\u0000${row.target_id.toLowerCase()}\u0000${row.dependency_kind}`, row);
+        }
+    }
+    return [...contradictions.values()].sort((left, right) => {
+        const holderCompare = compareCaseFoldedText(left.holder_id, right.holder_id);
+        if (holderCompare !== 0)
+            return holderCompare;
+        const targetCompare = compareCaseFoldedText(left.target_id, right.target_id);
+        if (targetCompare !== 0)
+            return targetCompare;
+        return compareCaseFoldedText(left.dependency_kind, right.dependency_kind);
+    });
+}
 /**
  * Classify missing hierarchy and dependency targets without mutating their holders.
  *
@@ -296,8 +347,9 @@ export function assembleWorkspaceRelationshipGraph(items, isTerminal, registry)
         missingIdSet: new Set(missingIds.map((id) => id.toLowerCase())),
         dangling,
         duplicateRows: collectDuplicateDependencyRows(safeItems, isTerminal),
+        orderingContradictions: collectOrderingStorageContradictions(safeItems, isTerminal, relationshipRegistry),
         legacyAliasCounts: collectLegacyDependencyAliasCounts(safeItems, relationshipRegistry),
     };
 }
 //# sourceMappingURL=assembly.js.map
-//# debugId=62ec8e0e-658e-5a32-b458-439d5ffd1229
+//# debugId=a6fc5da1-b7d1-5b3c-8033-cecccc7861c3

package/dist/sdk/graph/durable-cache.js

@@ -15,7 +15,7 @@
  * threshold or after an explicit `pm graph index --rebuild` opt-in.
  */
 
-!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]="2f7f14e3-6d41-5f45-a560-ebfbb8aa5828")}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]="9e4aa41d-fca4-5e55-ab2b-d99f06d90ae2")}catch(e){}}();
 import path from "node:path";
 import { readFileIfExists, removeFileIfExists, writeFileAtomic, } from "../../core/fs/fs-utils.js";
 import { acquireLock } from "../../core/lock/lock.js";
@@ -174,8 +174,52 @@ function isNonnegativeCoverageByTypeRecord(value) {
     return Object.values(value).every((entry) => isRecord(entry) &&
         [entry.active, entry.isolated, entry.degree_leq_one].every(isNonnegativeInteger));
 }
+/** Decode the additive information-bearing census as one coherent field group. */
+function decodeInformativeProfile(profile, nodes, edges) {
+    const fields = [
+        "recorded_nodes",
+        "informative_edges",
+        "redundant_edges",
+        "ordering_contradiction_edges",
+    ];
+    const presentCount = fields.filter((field) => profile[field] !== undefined).length;
+    if (presentCount !== 0 && presentCount !== fields.length)
+        return undefined;
+    if (!fields.every((field) => isOptionalValid(profile[field], isNonnegativeInteger)))
+        return undefined;
+    const decoded = {
+        recorded_nodes: profile.recorded_nodes ?? nodes,
+        informative_edges: profile.informative_edges ?? edges,
+        redundant_edges: profile.redundant_edges ?? 0,
+        ordering_contradiction_edges: profile.ordering_contradiction_edges ?? 0,
+    };
+    return decoded.recorded_nodes <= nodes &&
+        decoded.informative_edges <= edges &&
+        decoded.redundant_edges <= edges &&
+        decoded.ordering_contradiction_edges <= edges
+        ? decoded
+        : undefined;
+}
+/** Validate the optional structural census fields as one complete version group. */
+function hasValidStructuralFields(profile, countFields, rateFields) {
+    const introducedFields = [
+        ...countFields,
+        ...rateFields,
+        "finding_subjects_by_code",
+    ];
+    const presentCount = introducedFields.filter((field) => profile[field] !== undefined).length;
+    if (presentCount !== 0 && presentCount !== introducedFields.length)
+        return false;
+    return (countFields.every((field) => isOptionalValid(profile[field], isNonnegativeInteger)) &&
+        rateFields.every((field) => isOptionalValid(profile[field], isNonnegativeInteger) &&
+            (profile[field] === undefined || Number(profile[field]) <= 10_000)) &&
+        isOptionalValid(profile.finding_subjects_by_code, isNonnegativeCountRecord));
+}
 /** Decode optional structural fields while normalizing pre-structure baselines. */
-function decodeStructuralProfile(profile, affectedSubjectsByCode) {
+function decodeStructuralProfile(profile, affectedSubjectsByCode, nodes, edges) {
+    const informative = decodeInformativeProfile(profile, nodes, edges);
+    if (informative === undefined)
+        return undefined;
     const countFields = [
         "articulation_points",
         "bridge_edges",
@@ -193,31 +237,17 @@ function decodeStructuralProfile(profile, affectedSubjectsByCode) {
         "terminal_outcome_reachability_basis_points",
         "outcome_reachability_basis_points",
     ];
-    const introducedStructuralFields = [
-        ...countFields,
-        ...rateFields,
-        "finding_subjects_by_code",
-    ];
-    const introducedStructuralFieldCount = introducedStructuralFields.filter((field) => profile[field] !== undefined).length;
-    if (introducedStructuralFieldCount !== 0 &&
-        introducedStructuralFieldCount !== introducedStructuralFields.length) {
-        return undefined;
-    }
-    const validCounts = countFields.every((field) => profile[field] === undefined || isNonnegativeInteger(profile[field]));
-    const validRates = rateFields.every((field) => profile[field] === undefined ||
-        (isNonnegativeInteger(profile[field]) && Number(profile[field]) <= 10_000));
-    if (!validCounts || !validRates)
+    if (!hasValidStructuralFields(profile, countFields, rateFields))
         return undefined;
     if (profile.edge_basis !== undefined &&
         profile.edge_basis !== "deduplicated_directed")
         return undefined;
-    if (!isOptionalValid(profile.finding_subjects_by_code, isNonnegativeCountRecord))
-        return undefined;
     const findingSubjects = isNonnegativeCountRecord(profile.finding_subjects_by_code)
         ? profile.finding_subjects_by_code
         : {};
     return {
         edge_basis: "deduplicated_directed",
+        ...informative,
         ...Object.fromEntries(countFields.map((field) => [field, profile[field] ?? 0])),
         ...Object.fromEntries(rateFields.map((field) => [field, profile[field] ?? 0])),
         finding_subjects_by_code: Object.fromEntries(RELATIONSHIP_AUDIT_FINDING_CODES.map((code) => [
@@ -302,7 +332,7 @@ function decodeBaseline(raw) {
         const composition = decodeGraphComposition(profile.edges, profile.edges_by_kind, profile.edge_share_by_kind, profile.semantic_edges, profile.semantic_edge_share);
         if (composition === undefined)
             return undefined;
-        const structural = decodeStructuralProfile(profile, affectedSubjectsByCode);
+        const structural = decodeStructuralProfile(profile, affectedSubjectsByCode, profile.nodes, profile.edges);
         if (structural === undefined)
             return undefined;
         const { coverage_by_type = {} } = profile;
@@ -329,4 +359,4 @@ export async function saveGraphAuditBaseline(pmRoot, snapshot) {
     await writeFileAtomic(graphAuditBaselinePath(pmRoot), JSON.stringify(snapshot));
 }
 //# sourceMappingURL=durable-cache.js.map
-//# debugId=2f7f14e3-6d41-5f45-a560-ebfbb8aa5828
+//# debugId=9e4aa41d-fca4-5e55-ab2b-d99f06d90ae2

package/dist/sdk/graph/governance-contracts.d.ts

@@ -7,6 +7,6 @@
  * drifting when a finding family is added.
  */
 /** Stable machine-readable relationship audit finding families. */
-export declare const RELATIONSHIP_AUDIT_FINDING_CODES: readonly ["missing_reference_active", "missing_reference_terminal", "legacy_no_blocker_sentinel", "ordering_cycle", "legacy_ordering_cycle", "duplicate_edge", "legacy_duplicate_edge", "duplicate_dependency_row", "legacy_duplicate_dependency_row", "stale_lifecycle_block", "isolated_active_node", "sparse_active_node"];
+export declare const RELATIONSHIP_AUDIT_FINDING_CODES: readonly ["missing_reference_active", "missing_reference_terminal", "legacy_no_blocker_sentinel", "ordering_cycle", "legacy_ordering_cycle", "ordering_storage_contradiction", "legacy_ordering_storage_contradiction", "duplicate_edge", "legacy_duplicate_edge", "duplicate_dependency_row", "legacy_duplicate_dependency_row", "stale_lifecycle_block", "isolated_active_node", "sparse_active_node"];
 /** Machine-readable identifier for one relationship audit finding family. */
 export type RelationshipAuditFindingCode = (typeof RELATIONSHIP_AUDIT_FINDING_CODES)[number];

package/dist/sdk/graph/governance-contracts.js

@@ -8,13 +8,15 @@
  */
 /** Stable machine-readable relationship audit finding families. */
 
-!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]="a2043b27-3dfe-5da8-a10f-d92ff33f3c28")}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]="bc561e73-75b8-5ea7-a18c-da70fb991b69")}catch(e){}}();
 export const RELATIONSHIP_AUDIT_FINDING_CODES = [
     "missing_reference_active",
     "missing_reference_terminal",
     "legacy_no_blocker_sentinel",
     "ordering_cycle",
     "legacy_ordering_cycle",
+    "ordering_storage_contradiction",
+    "legacy_ordering_storage_contradiction",
     "duplicate_edge",
     "legacy_duplicate_edge",
     "duplicate_dependency_row",
@@ -24,4 +26,4 @@ export const RELATIONSHIP_AUDIT_FINDING_CODES = [
     "sparse_active_node",
 ];
 //# sourceMappingURL=governance-contracts.js.map
-//# debugId=a2043b27-3dfe-5da8-a10f-d92ff33f3c28
+//# debugId=bc561e73-75b8-5ea7-a18c-da70fb991b69

package/dist/sdk/graph/governance.d.ts

@@ -13,7 +13,7 @@
  * agents can plan remediation without re-deriving context.
  */
 import type { RelationshipEdge } from "../relationships.js";
-import type { WorkspaceRelationshipAssembly } from "./assembly.js";
+import type { OrderingStorageContradiction, WorkspaceRelationshipAssembly } from "./assembly.js";
 import { type RelationshipAuditFindingCode } from "./governance-contracts.js";
 export type { RelationshipAuditFindingCode } from "./governance-contracts.js";
 /** Severity ladder shared by every relationship audit finding. */
@@ -32,6 +32,8 @@ export interface RelationshipAuditFinding {
     count: number;
     /** Deterministic bounded sample of affected subjects. */
     sample: string[];
+    /** Optional exact evidence that explains why the sampled subjects were selected. */
+    evidence?: string[];
     /** Whether {@link sample} was truncated by the configured sample bound. */
     sample_truncated: boolean;
     /** Safe machine-actionable next step; audits never invent or auto-apply edges. */
@@ -50,8 +52,16 @@ export interface RelationshipCoverageTypeProfile {
 export interface RelationshipCoverageProfile {
     /** Total indexed nodes including materialized missing placeholders. */
     nodes: number;
+    /** Tracker-recorded nodes, excluding synthesized missing and external placeholders. */
+    recorded_nodes?: number;
     /** Total deduplicated indexed edges. */
     edges: number;
+    /** Edges that remain after excluding redundant and contradictory storage rows. */
+    informative_edges?: number;
+    /** Stored edges implied by a bounded longer path in the same semantic family. */
+    redundant_edges?: number;
+    /** Structured ordering edges that contradict a same-target scalar blocker. */
+    ordering_contradiction_edges?: number;
     /** Counting convention used by edges and edges_by_kind. */
     edge_basis: "deduplicated_directed";
     /** Deterministic per-kind edge counts. */
@@ -134,6 +144,8 @@ export declare function isSemanticContextKind(kind: string): boolean;
  * advisories) share one cycle semantics with the workspace audit.
  */
 export declare function collectOrderingCycles(successors: Map<string, string[]>): string[][];
+/** Format the exact contradictory storage pair that manufactures an ordering cycle. */
+export declare function formatOrderingStorageContradiction(contradiction: Pick<OrderingStorageContradiction, "holder_id" | "target_id" | "dependency_kind">): string;
 /** One duplicate-edge group in semantic orientation with its stored spellings. */
 export interface DuplicateRelationshipEdgeGroup {
     /** Semantic tail node shared by every stored spelling. */
@@ -189,8 +201,16 @@ export interface RelationshipAuditDelta {
     profile: {
         /** Node-count change including missing placeholders. */
         nodes: number;
+        /** Tracker-recorded node-count change excluding synthesized placeholders. */
+        recorded_nodes?: number;
         /** Deduplicated edge-count change. */
         edges: number;
+        /** Informative edge-count change after non-information deductions. */
+        informative_edges?: number;
+        /** Redundant edge-count change. */
+        redundant_edges?: number;
+        /** Ordering contradiction edge-count change. */
+        ordering_contradiction_edges?: number;
         /** Active-node-count change. */
         active_nodes: number;
         /** Missing-placeholder-count change. */

package/dist/sdk/graph/governance.js

@@ -1,6 +1,6 @@
 
-!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]="ab8a4904-0302-5e36-9963-750b3ba79876")}catch(e){}}();
-import { isTransitiveKind, orientTransitiveEdge, transitiveFamilyKey, } from "./analytics.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]="1955b7a4-385d-5a5d-8856-6db9f94814aa")}catch(e){}}();
+import { findRedundantRelationshipEdges, isTransitiveKind, orientTransitiveEdge, transitiveFamilyKey, } from "./analytics.js";
 import { findRelationshipCutStructure } from "./centrality.js";
 import { RELATIONSHIP_AUDIT_FINDING_CODES, } from "./governance-contracts.js";
 /** Default bounded sample size applied to every finding family. */
@@ -25,8 +25,14 @@ const SEVERITY_RANK = {
     warning: 1,
     info: 2,
 };
+/** Normalize optional exemption identifiers into a case-insensitive lookup set. */
+function normalizeExemptionSet(values) {
+    return new Set((values ?? [])
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim().toLowerCase()));
+}
 /** Build one finding with deterministic bounded sampling over sorted subjects. */
-function buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation) {
+function buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation, evidence) {
     const sorted = [...subjects].sort((left, right) => left.localeCompare(right));
     return {
         code,
@@ -37,6 +43,13 @@ function buildFinding(code, severity, policy, describe, subjects, maxSampleSize,
         sample: sorted.slice(0, maxSampleSize),
         sample_truncated: sorted.length > maxSampleSize,
         remediation,
+        ...(evidence === undefined
+            ? {}
+            : {
+                evidence: [...evidence]
+                    .sort((left, right) => left.localeCompare(right))
+                    .slice(0, maxSampleSize),
+            }),
     };
 }
 /** Resolve the ordering-only successor adjacency for cycle analysis. */
@@ -177,6 +190,21 @@ function isActiveAuditMember(member, nodeStates) {
         return true;
     return !state.terminal;
 }
+/** Format the exact contradictory storage pair that manufactures an ordering cycle. */
+export function formatOrderingStorageContradiction(contradiction) {
+    return `${contradiction.holder_id} -> ${contradiction.target_id} (blocked_by scalar + ${contradiction.dependency_kind} dependency)`;
+}
+/** Report active and historical scalar-versus-structured ordering contradictions. */
+function collectOrderingStorageContradictionFindings(assembly, maxSampleSize) {
+    const active = [];
+    const legacy = [];
+    for (const contradiction of assembly.orderingContradictions ?? [])
+        (contradiction.legacy_terminal ? legacy : active).push(formatOrderingStorageContradiction(contradiction));
+    const findings = [];
+    appendFinding(findings, active, maxSampleSize, "ordering_storage_contradiction", "error", "A scalar blocker and same-target structured ordering row must not assert opposite precedence.", (count) => `${count} active scalar-versus-structured ordering contradiction(s)`, "Remove the structured dependency row that points the holder before its scalar blocker, or replace both representations with one unambiguous ordering edge.");
+    appendFinding(findings, legacy, maxSampleSize, "legacy_ordering_storage_contradiction", "info", "Terminal scalar-versus-structured ordering contradictions are exact historical storage defects with no live scheduling effect.", (count) => `${count} terminal scalar-versus-structured ordering contradiction(s)`, "Remove the contradictory blocks dependency row in a dedicated changelog-safe closed-item batch; preserve the scalar blocker as the historical precedence record.");
+    return findings;
+}
 /** Collect ordering-cycle and lifecycle-block governance findings. */
 function collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize) {
     const findings = [];
@@ -186,9 +214,18 @@ function collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize)
         // it cannot make live work unschedulable, and "repairing" it would touch
         // closed items (changelog drag), so it downgrades to informational debt.
         const active = cycle.some((member) => isActiveAuditMember(member, nodeStates));
+        const cycleMembers = new Set(cycle.map((member) => member.toLowerCase()));
+        const contradictionEvidence = (assembly.orderingContradictions ?? [])
+            .filter((row) => cycleMembers.has(row.holder_id.toLowerCase()) &&
+            cycleMembers.has(row.target_id.toLowerCase()))
+            .map(formatOrderingStorageContradiction);
         findings.push(active
-            ? buildFinding("ordering_cycle", "error", "Order-bearing relationship kinds must stay acyclic; a cycle makes every member unschedulable.", (count) => `execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Remove or retype one ordering edge inside the cycle, or split the work so precedence is linear.")
-            : buildFinding("legacy_ordering_cycle", "info", "Ordering cycles between exclusively terminal items are historical contradictions with no scheduling effect.", (count) => `terminal-only execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Leave as history debt, or clean up in a dedicated changelog-safe closed-item batch; never repair closed items ad hoc."));
+            ? buildFinding("ordering_cycle", "error", "Order-bearing relationship kinds must stay acyclic; a cycle makes every member unschedulable.", (count) => `execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Remove or retype one ordering edge inside the cycle, or split the work so precedence is linear.", contradictionEvidence.length === 0
+                ? undefined
+                : contradictionEvidence)
+            : buildFinding("legacy_ordering_cycle", "info", "Ordering cycles between exclusively terminal items are historical contradictions with no scheduling effect.", (count) => `terminal-only execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Leave as history debt, or clean up in a dedicated changelog-safe closed-item batch; never repair closed items ad hoc.", contradictionEvidence.length === 0
+                ? undefined
+                : contradictionEvidence));
     }
     const predecessorsByNode = new Map();
     for (const [predecessor, adjacent] of orderingAdjacency)
@@ -448,6 +485,12 @@ function collectCoverageReport(assembly, nodeStates, exemptIsolates, isolateExem
     appendFinding(findings, isolates, maxSampleSize, "isolated_active_node", "warning", "Active work should be reachable from the graph unless explicitly declared a valid isolate.", (count) => `${count} active item(s) with no relationships`, "Link the item to its parent, prerequisite, or origin — or register it as an exempt isolate.");
     appendFinding(findings, sparse, maxSampleSize, "sparse_active_node", "info", "Active items with a single edge often miss an honest semantic partner; sparse is not automatically defective.", (count) => `${count} active item(s) with exactly one relationship`, "Investigate for an honest second edge (story->task, defect family, cross-epic complement); do not fabricate one.");
     const edgeCount = assembly.graph.edges().length;
+    const redundantEdges = findRedundantRelationshipEdges(assembly.graph, {
+        signal,
+    }).value;
+    const nonInformativeEdgeKeys = new Set(redundantEdges.map(({ edge }) => `${edge.source.toLowerCase()}\u0000${edge.target.toLowerCase()}\u0000${edge.kind}`));
+    for (const contradiction of assembly.orderingContradictions ?? [])
+        nonInformativeEdgeKeys.add(`${contradiction.holder_id.toLowerCase()}\u0000${contradiction.target_id.toLowerCase()}\u0000${contradiction.dependency_kind}`);
     const sortedEdgesByKind = Object.fromEntries(Object.entries(edgesByKind).sort(([left], [right]) => left.localeCompare(right)));
     const semanticEdges = Object.entries(sortedEdgesByKind).reduce((count, [kind, value]) => count + (isSemanticContextKind(kind) ? value : 0), 0);
     const cutStructure = findRelationshipCutStructure(assembly.graph, {
@@ -458,7 +501,11 @@ function collectCoverageReport(assembly, nodeStates, exemptIsolates, isolateExem
         findings,
         profile: {
             nodes: assembly.graph.nodes().length,
+            recorded_nodes: assembly.details.filter((detail) => detail.status !== "missing" && detail.status !== "external").length,
             edges: edgeCount,
+            informative_edges: edgeCount - nonInformativeEdgeKeys.size,
+            redundant_edges: redundantEdges.length,
+            ordering_contradiction_edges: assembly.orderingContradictions?.length ?? 0,
             edge_basis: "deduplicated_directed",
             edges_by_kind: sortedEdgesByKind,
             edge_share_by_kind: Object.fromEntries(Object.entries(sortedEdgesByKind).map(([kind, count]) => [
@@ -496,12 +543,8 @@ export function auditWorkspaceRelationshipGraph(assembly, options = {}) {
     const maxSampleSize = options.maxSampleSize ?? DEFAULT_MAX_SAMPLE_SIZE;
     if (!Number.isInteger(maxSampleSize) || maxSampleSize < 1)
         throw new TypeError(`Invalid audit sample bound: ${String(options.maxSampleSize)}`);
-    const exemptIsolates = new Set((options.exemptIsolates ?? [])
-        .filter((id) => typeof id === "string")
-        .map((id) => id.trim().toLowerCase()));
-    const isolateExemptTypes = new Set((options.isolateExemptTypes ?? [])
-        .filter((type) => typeof type === "string")
-        .map((type) => type.trim().toLowerCase()));
+    const exemptIsolates = normalizeExemptionSet(options.exemptIsolates);
+    const isolateExemptTypes = normalizeExemptionSet(options.isolateExemptTypes);
     const nodeStates = new Map(assembly.details.map((detail) => [
         detail.id,
         {
@@ -518,6 +561,8 @@ export function auditWorkspaceRelationshipGraph(assembly, options = {}) {
         edgesByKind[edge.kind] = (edgesByKind[edge.kind] ?? 0) + 1;
     const findings = collectIntegrityFindings(assembly, isTerminal, maxSampleSize);
     options.signal?.throwIfAborted();
+    findings.push(...collectOrderingStorageContradictionFindings(assembly, maxSampleSize));
+    options.signal?.throwIfAborted();
     findings.push(...collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize));
     options.signal?.throwIfAborted();
     findings.push(...collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize), ...collectDuplicateRowFindings(assembly, maxSampleSize));
@@ -556,45 +601,62 @@ function diffCountRecords(baseline, current) {
 function readSnapshotCoverageByType(snapshot) {
     return snapshot.profile.coverage_by_type ?? {};
 }
-/**
- * Compare two point-in-time audit snapshots and return the signed change in
- * findings and structural coverage. This is the temporal primitive behind
- * change-since-baseline audit reporting: agents track census drift across
- * sessions without re-deriving or storing full finding collections.
- */
-export function diffRelationshipAuditSnapshots(baseline, current) {
-    const coverageByType = {};
-    // Public SDK callers may compare legacy or JSON-decoded snapshots created
-    // before per-type coverage was added, even though current typed snapshots
-    // always carry this field.
-    const baselineCoverageByType = readSnapshotCoverageByType(baseline);
-    const currentCoverageByType = readSnapshotCoverageByType(current);
-    const typeKeys = [
+/** Diff per-type coverage while omitting unchanged type rows. */
+function diffCoverageByType(baseline, current) {
+    const deltas = {};
+    const baselineCoverage = readSnapshotCoverageByType(baseline);
+    const currentCoverage = readSnapshotCoverageByType(current);
+    const types = [
         ...new Set([
-            ...Object.keys(baselineCoverageByType),
-            ...Object.keys(currentCoverageByType),
+            ...Object.keys(baselineCoverage),
+            ...Object.keys(currentCoverage),
         ]),
     ].sort();
-    for (const type of typeKeys) {
-        const before = Object.assign({ active: 0, isolated: 0, degree_leq_one: 0 }, baselineCoverageByType[type]);
-        const after = Object.assign({ active: 0, isolated: 0, degree_leq_one: 0 }, currentCoverageByType[type]);
+    for (const type of types) {
+        const before = Object.assign({ active: 0, isolated: 0, degree_leq_one: 0 }, baselineCoverage[type]);
+        const after = Object.assign({ active: 0, isolated: 0, degree_leq_one: 0 }, currentCoverage[type]);
         const delta = {
             active: after.active - before.active,
             isolated: after.isolated - before.isolated,
             degree_leq_one: after.degree_leq_one - before.degree_leq_one,
         };
         if (Object.values(delta).some((value) => value !== 0))
-            coverageByType[type] = delta;
+            deltas[type] = delta;
     }
+    return deltas;
+}
+/**
+ * Compare two point-in-time audit snapshots and return the signed change in
+ * findings and structural coverage. This is the temporal primitive behind
+ * change-since-baseline audit reporting: agents track census drift across
+ * sessions without re-deriving or storing full finding collections.
+ */
+export function diffRelationshipAuditSnapshots(baseline, current) {
+    // Public SDK callers may compare legacy or JSON-decoded snapshots created
+    // before per-type coverage was added, even though current typed snapshots
+    // always carry this field.
+    const coverageByType = diffCoverageByType(baseline, current);
     const { edge_share_by_kind: baselineEdgeShareByKind = {}, semantic_edges: baselineSemanticEdges = 0, semantic_edge_share: baselineSemanticEdgeShare = 0, } = baseline.profile;
     const { edge_share_by_kind: currentEdgeShareByKind = {}, semantic_edges: currentSemanticEdges = 0, semantic_edge_share: currentSemanticEdgeShare = 0, } = current.profile;
+    const baselineRecordedNodes = baseline.profile.recorded_nodes ?? baseline.profile.nodes;
+    const currentRecordedNodes = current.profile.recorded_nodes ?? current.profile.nodes;
+    const baselineInformativeEdges = baseline.profile.informative_edges ?? baseline.profile.edges;
+    const currentInformativeEdges = current.profile.informative_edges ?? current.profile.edges;
+    const baselineRedundantEdges = baseline.profile.redundant_edges ?? 0;
+    const currentRedundantEdges = current.profile.redundant_edges ?? 0;
+    const baselineOrderingContradictionEdges = baseline.profile.ordering_contradiction_edges ?? 0;
+    const currentOrderingContradictionEdges = current.profile.ordering_contradiction_edges ?? 0;
     return {
         baseline_saved_at: baseline.saved_at,
         same_snapshot: baseline.fingerprint === current.fingerprint,
         affected_subjects_by_code: diffCountRecords(baseline.affected_subjects_by_code, current.affected_subjects_by_code),
         profile: {
             nodes: current.profile.nodes - baseline.profile.nodes,
+            recorded_nodes: currentRecordedNodes - baselineRecordedNodes,
             edges: current.profile.edges - baseline.profile.edges,
+            informative_edges: currentInformativeEdges - baselineInformativeEdges,
+            redundant_edges: currentRedundantEdges - baselineRedundantEdges,
+            ordering_contradiction_edges: currentOrderingContradictionEdges - baselineOrderingContradictionEdges,
             active_nodes: current.profile.active_nodes - baseline.profile.active_nodes,
             missing_nodes: current.profile.missing_nodes - baseline.profile.missing_nodes,
             isolated_active_nodes: current.profile.isolated_active_nodes -
@@ -610,4 +672,4 @@ export function diffRelationshipAuditSnapshots(baseline, current) {
     };
 }
 //# sourceMappingURL=governance.js.map
-//# debugId=ab8a4904-0302-5e36-9963-750b3ba79876
+//# debugId=1955b7a4-385d-5a5d-8856-6db9f94814aa

package/dist/sdk/graph/index.d.ts

@@ -12,8 +12,8 @@ export { computeRelationshipCentrality, findRelationshipCutStructure, type Graph
 export { createRelationshipGraphSnapshot, federateRelationshipGraphSnapshots, loadRelationshipGraphAdapter, MemoryRelationshipGraphAdapter, parseRelationshipGraphSnapshot, RELATIONSHIP_GRAPH_SNAPSHOT_VERSION, syncRelationshipGraphAdapter, type LoadedRelationshipGraphSnapshot, type RelationshipGraphAdapter, type RelationshipGraphAdapterContext, type RelationshipGraphAdapterReplaceContext, type RelationshipGraphAdapterSyncResult, type RelationshipGraphSnapshot, } from "./adapter.js";
 export { assertMemoryRelationshipGraphAdapterConformance, assertRelationshipGraphAdapterConformance, createRelationshipGraphScaleFixture, type RelationshipGraphAdapterConformanceCase, type RelationshipGraphAdapterConformanceReport, type RelationshipGraphScaleFixture, type RelationshipGraphScaleFixtureOptions, type RelationshipGraphScaleTopology, } from "./conformance.js";
 export { analyzeRelationshipSchedule, type GraphScheduleOptions, type RelationshipScheduleAnalysis, type RelationshipScheduleRow, } from "./scheduling.js";
-export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectDuplicateDependencyRows, collectMissingDependencyTargetIds, normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, type DanglingDependencyReference, type DanglingDependencyReferenceSummary, type DependencyReferenceHolder, type DependencyReferenceSource, type DuplicateDependencyRow, type WorkspaceRelationshipAssembly, type WorkspaceRelationshipItem, type WorkspaceRelationshipNodeDetails, } from "./assembly.js";
-export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, collectOrderingCycles, diffRelationshipAuditSnapshots, formatDuplicateEdgeGroup, type DuplicateRelationshipEdgeGroup, type RelationshipAuditDelta, type RelationshipAuditFinding, type RelationshipAuditFindingCode, type RelationshipAuditOptions, type RelationshipAuditReport, type RelationshipAuditSeverity, type RelationshipAuditSnapshot, type RelationshipCoverageProfile, type RelationshipCoverageTypeProfile, } from "./governance.js";
+export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectDuplicateDependencyRows, collectMissingDependencyTargetIds, collectOrderingStorageContradictions, normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, type DanglingDependencyReference, type DanglingDependencyReferenceSummary, type DependencyReferenceHolder, type DependencyReferenceSource, type DuplicateDependencyRow, type OrderingStorageContradiction, type WorkspaceRelationshipAssembly, type WorkspaceRelationshipItem, type WorkspaceRelationshipNodeDetails, } from "./assembly.js";
+export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, collectOrderingCycles, diffRelationshipAuditSnapshots, formatDuplicateEdgeGroup, formatOrderingStorageContradiction, type DuplicateRelationshipEdgeGroup, type RelationshipAuditDelta, type RelationshipAuditFinding, type RelationshipAuditFindingCode, type RelationshipAuditOptions, type RelationshipAuditReport, type RelationshipAuditSeverity, type RelationshipAuditSnapshot, type RelationshipCoverageProfile, type RelationshipCoverageTypeProfile, } from "./governance.js";
 export { clearDurableGraphCache, durableGraphCachePath, durableGraphCacheStatus, GRAPH_DURABLE_CACHE_MIN_ITEMS, GRAPH_DURABLE_CACHE_VERSION, graphAuditBaselinePath, loadGraphAuditBaseline, openDurableGraphCache, persistDurableGraphResult, saveGraphAuditBaseline, shouldPersistDurableGraphCache, type DurableGraphCacheEnvelope, type DurableGraphCacheStatus, type DurableGraphCacheView, } from "./durable-cache.js";
 export { enumerateRelationshipPaths, hierarchyAncestors, hierarchyDescendants, orderingPredecessors, orderingSuccessors, type GraphPathOptions, type GraphTraversalOptions, type RelationshipPath, } from "./traversal.js";
 export { computeWorkspaceGraphFingerprint, resetWorkspaceGraphCache, workspaceGraphCache, WorkspaceGraphCache, type GraphCacheMetadata, type WorkspaceGraphCacheLookup, } from "./cache.js";

package/dist/sdk/graph/index.js

@@ -8,14 +8,14 @@
  * `sdk/relationships` and is safe for CLI, MCP, extension, and non-PM callers.
  */
 
-!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]="2c3df51e-6b10-5da6-8340-126465d9c434")}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]="b5509c6e-1431-5316-a563-16681ced4f33")}catch(e){}}();
 export { computeRelationshipDominators, detectRelationshipCommunities, findRedundantRelationshipEdges, forEachMatchedRelationshipEdge, } from "./analytics.js";
 export { computeRelationshipCentrality, findRelationshipCutStructure, } from "./centrality.js";
 export { createRelationshipGraphSnapshot, federateRelationshipGraphSnapshots, loadRelationshipGraphAdapter, MemoryRelationshipGraphAdapter, parseRelationshipGraphSnapshot, RELATIONSHIP_GRAPH_SNAPSHOT_VERSION, syncRelationshipGraphAdapter, } from "./adapter.js";
 export { assertMemoryRelationshipGraphAdapterConformance, assertRelationshipGraphAdapterConformance, createRelationshipGraphScaleFixture, } from "./conformance.js";
 export { analyzeRelationshipSchedule, } from "./scheduling.js";
-export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectDuplicateDependencyRows, collectMissingDependencyTargetIds, normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, } from "./assembly.js";
-export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, collectOrderingCycles, diffRelationshipAuditSnapshots, formatDuplicateEdgeGroup, } from "./governance.js";
+export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectDuplicateDependencyRows, collectMissingDependencyTargetIds, collectOrderingStorageContradictions, normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, } from "./assembly.js";
+export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, collectOrderingCycles, diffRelationshipAuditSnapshots, formatDuplicateEdgeGroup, formatOrderingStorageContradiction, } from "./governance.js";
 export { clearDurableGraphCache, durableGraphCachePath, durableGraphCacheStatus, GRAPH_DURABLE_CACHE_MIN_ITEMS, GRAPH_DURABLE_CACHE_VERSION, graphAuditBaselinePath, loadGraphAuditBaseline, openDurableGraphCache, persistDurableGraphResult, saveGraphAuditBaseline, shouldPersistDurableGraphCache, } from "./durable-cache.js";
 export { enumerateRelationshipPaths, hierarchyAncestors, hierarchyDescendants, orderingPredecessors, orderingSuccessors, } from "./traversal.js";
 export { computeWorkspaceGraphFingerprint, resetWorkspaceGraphCache, workspaceGraphCache, WorkspaceGraphCache, } from "./cache.js";
@@ -23,4 +23,4 @@ export { planRelationshipRemediation, } from "./remediation.js";
 export { collectNewOrderingCycleWarnings } from "./mutation-advisory.js";
 export { GRAPH_SUBCOMMAND_VALUES, parseGraphSubcommand, runGraph, } from "./run.js";
 //# sourceMappingURL=index.js.map
-//# debugId=2c3df51e-6b10-5da6-8340-126465d9c434
+//# debugId=b5509c6e-1431-5316-a563-16681ced4f33

package/dist/sdk/graph/mutation-advisory.js

@@ -1,7 +1,7 @@
 
-!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]="4198a3b2-2541-50eb-bec5-93ac58601f40")}catch(e){}}();
-import { normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, } from "./assembly.js";
-import { collectOrderingCycles } from "./governance.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]="94e8b95b-35fa-5fc7-843a-481497e09b54")}catch(e){}}();
+import { collectOrderingStorageContradictions, normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, } from "./assembly.js";
+import { collectOrderingCycles, formatOrderingStorageContradiction, } from "./governance.js";
 function cycleKey(component) {
     return [...component].sort().join("\u0000");
 }
@@ -153,9 +153,17 @@ export function collectNewOrderingCycleWarnings(beforeItems, afterItems, changed
     const before = collectScopedCycles(beforeItems, registry, changedItemId);
     const after = collectScopedCycles(afterItems, registry, changedItemId);
     const beforeCycles = new Set(before.cycles.map(cycleKey));
-    return after.cycles
-        .filter((component) => !beforeCycles.has(cycleKey(component)))
-        .map((component) => `ordering_cycle_created:${findCyclePath(after.successors, component, after.canonical).join(" -> ")}:items_will_not_be_ready:run_pm_graph_audit`);
+    const beforeContradictions = new Set(collectOrderingStorageContradictions(beforeItems, undefined, registry).map((row) => `${row.holder_id.toLowerCase()}\u0000${row.target_id.toLowerCase()}\u0000${row.dependency_kind}`));
+    const contradictionWarnings = collectOrderingStorageContradictions(afterItems, undefined, registry)
+        .filter((row) => row.holder_id.toLowerCase() === changedItemId.trim().toLowerCase() &&
+        !beforeContradictions.has(`${row.holder_id.toLowerCase()}\u0000${row.target_id.toLowerCase()}\u0000${row.dependency_kind}`))
+        .map((row) => `ordering_storage_contradiction_created:${formatOrderingStorageContradiction(row)}:remove_contradicting_dependency_row:run_pm_graph_audit`);
+    return [
+        ...contradictionWarnings,
+        ...after.cycles
+            .filter((component) => !beforeCycles.has(cycleKey(component)))
+            .map((component) => `ordering_cycle_created:${findCyclePath(after.successors, component, after.canonical).join(" -> ")}:items_will_not_be_ready:run_pm_graph_audit`),
+    ];
 }
 /** White-box graph-path helpers for exhaustive SDK primitive verification. */
 export const mutationAdvisoryTestOnly = {
@@ -166,4 +174,4 @@ export const mutationAdvisoryTestOnly = {
     findPathBackToStart,
 };
 //# sourceMappingURL=mutation-advisory.js.map
-//# debugId=4198a3b2-2541-50eb-bec5-93ac58601f40
+//# debugId=94e8b95b-35fa-5fc7-843a-481497e09b54