@unbrained/pm-cli 2026.7.20 → 2026.7.21

package/dist/cli-bundle/chunks/{chunk-NHT3F4WZ.js → chunk-NUF7ROFH.js}

@@ -1,9 +1,9 @@
 
-!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]="4c8b3841-40b8-5707-9154-ff020ed23bfd")}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]="405abecd-c7c4-543d-be2a-eb3e5168def7")}catch(e){}}();
 import {
   collectStaleVectorizationIds,
   recordContextUsageTouches
-} from "./chunk-YQQNAKW3.js";
+} from "./chunk-JFD5LPMI.js";
 import {
   buildEventCorpus,
   buildPlanFlatCorpus,
@@ -16,15 +16,26 @@ import {
   resolveSearchCorpusFields,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-THAOZG4U.js";
+} from "./chunk-PQSEQD6E.js";
 import {
   GRAPH_SUBCOMMAND_VALUES
-} from "./chunk-UZDQXNUB.js";
+} from "./chunk-FSE2IKJQ.js";
 import {
-  analyzeGraphImpact,
-  analyzeKnowledgeGraph,
-  analyzeRelationshipExecution
-} from "./chunk-6C2ZZX5Z.js";
+  auditWorkspaceRelationshipGraph,
+  collectDuplicateRelationshipEdgeGroups,
+  computeRelationshipDominators,
+  detectRelationshipCommunities,
+  diffRelationshipAuditSnapshots,
+  enumerateRelationshipPaths,
+  findRedundantRelationshipEdges,
+  forEachMatchedRelationshipEdge,
+  formatDuplicateEdgeGroup,
+  hierarchyAncestors,
+  hierarchyDescendants,
+  orderingPredecessors,
+  orderingSuccessors,
+  orientOrderingEdge
+} from "./chunk-H7EAER5L.js";
 import {
   computeWorkspaceGraphFingerprint,
   parseDirection,
@@ -32,10 +43,11 @@ import {
   parseMaxDepth,
   parsePositiveInteger,
   workspaceGraphCache
-} from "./chunk-5IZJWSDB.js";
+} from "./chunk-OG5DVFMA.js";
 import {
-  assembleWorkspaceRelationshipGraph
-} from "./chunk-GSJSM5BJ.js";
+  assembleWorkspaceRelationshipGraph,
+  resolveWorkspaceRelationshipKindRegistry
+} from "./chunk-K36WV5J6.js";
 import {
   splitCommaList
 } from "./chunk-NETP4DY4.js";
@@ -76,11 +88,12 @@ import {
 } from "./chunk-4XGJLADW.js";
 import {
   getItemAt
-} from "./chunk-4L23AGQ7.js";
+} from "./chunk-Z7VWXXJM.js";
 import {
   readHistoryEntries
-} from "./chunk-2BO4CA46.js";
+} from "./chunk-PFNHX655.js";
 import {
+  acquireLock,
   buildItemNotFoundError,
   compareTimestampStrings,
   getActiveExtensionRegistrations,
@@ -107,18 +120,22 @@ import {
   coerceNumberInRange,
   coercePositiveInteger,
   collectRegisteredItemFieldNames,
+  createRelationshipKindRegistry,
   getHistoryPath,
   getItemPath,
   getSettingsPath,
   isPathWithinDirectory,
   pathExists,
+  readFileIfExists,
+  removeFileIfExists,
   resolveGlobalPmRoot,
   resolveItemTypeRegistry,
   resolvePmRoot,
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
   toNonEmptyString,
-  toNonEmptyStringOrUndefined
+  toNonEmptyStringOrUndefined,
+  writeFileAtomic
 } from "./chunk-HYW67VJ5.js";
 
 // dist/cli/commands/aggregate.js
@@ -463,866 +480,692 @@ async function runAggregate(options, global) {
   };
 }
 
-// dist/sdk/graph/traversal.js
-var DEFAULT_MAX_PATHS = 5;
-var DEFAULT_MAX_VISITED_PATHS = 1e4;
-var DEFAULT_PATH_MAX_DEPTH = 8;
-function assertPathBound(name, value) {
-  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0)
-    throw new TypeError(`Invalid path ${name} bound: ${String(value)}`);
-}
-function hierarchyParentEndpoint(edge, definition) {
-  return definition.hierarchyDirection === "target_parent" ? edge.target : edge.source;
-}
-function orderingPredecessorEndpoint(edge, definition) {
-  return (definition.precedence ?? "source_before_target") === "target_before_source" ? edge.target : edge.source;
-}
-function resolveFamilyKinds(graph, kinds, family) {
-  if (kinds === void 0)
-    return void 0;
-  const registry = graph.registry();
-  const resolved = /* @__PURE__ */ new Set();
-  for (const kind of kinds) {
-    const definition = registry.require(kind);
-    if (!definition[family])
-      throw new TypeError(`Relationship kind ${definition.kind} is not a ${family} kind`);
-    resolved.add(definition.kind);
-  }
-  return resolved;
-}
-function expandSemanticNeighbors(graph, nodeId, familyKinds, family, matches) {
-  const registry = graph.registry();
-  const rows = graph.neighborEdges(nodeId, {
-    direction: "both",
-    ...familyKinds === void 0 ? {} : { kinds: [...familyKinds] }
-  });
-  const neighbors = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const row of rows.value) {
-    const definition = registry.require(row.edge.kind);
-    if (!definition[family])
-      continue;
-    if (!matches(row, definition, nodeId))
+// dist/sdk/relationship-analytics.js
+function appendNeighbor(adjacency, source, target) {
+  adjacency.get(source).add(target);
+}
+function createAdjacency(nodes) {
+  return new Map(nodes.map((node) => [node, /* @__PURE__ */ new Set()]));
+}
+function sortComponents(components) {
+  for (const component of components)
+    component.sort();
+  return components.sort((left, right) => right.length - left.length || left[0].localeCompare(right[0]));
+}
+function stableJsonValue(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => stableJsonValue(entry));
+  if (value === null || typeof value !== "object")
+    return value;
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function")
+    return stableJsonValue(toJSON.call(value));
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableJsonValue(entry)]));
+}
+function relationshipEdgeKey(edge) {
+  return JSON.stringify(stableJsonValue(edge));
+}
+function appendFinishingOrder(start, adjacency, visited, order) {
+  const stack = [{ id: start, expanded: false }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current.expanded) {
+      order.push(current.id);
       continue;
-    if (seen.has(row.id))
+    }
+    if (visited.has(current.id))
       continue;
-    seen.add(row.id);
-    neighbors.push(row.id);
+    visited.add(current.id);
+    stack.push({ id: current.id, expanded: true });
+    const neighbors = [...adjacency.get(current.id)].sort().reverse();
+    for (const neighbor of neighbors)
+      if (!visited.has(neighbor))
+        stack.push({ id: neighbor, expanded: false });
   }
-  return { neighbors, inspectedEdges: rows.meta.inspectedEdges };
 }
-function appendSemanticExpansion(expansion, currentDepth, maxDepth, limit, after, state) {
-  if (currentDepth >= maxDepth) {
-    if (expansion.neighbors.some((neighbor) => !state.seen.has(neighbor)))
-      state.truncated = true;
-    return false;
-  }
-  for (const neighbor of expansion.neighbors) {
-    if (state.seen.has(neighbor))
-      continue;
-    state.seen.add(neighbor);
-    state.queue.push({ id: neighbor, depth: currentDepth + 1 });
-    if (!state.resumed) {
-      if (neighbor === after)
-        state.resumed = true;
+function computeFinishingOrder(nodes, adjacency) {
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  for (const start of nodes)
+    if (!visited.has(start))
+      appendFinishingOrder(start, adjacency, visited, order);
+  return order;
+}
+function collectReverseComponents(order, reverse) {
+  const visited = /* @__PURE__ */ new Set();
+  const components = [];
+  for (const start of [...order].reverse()) {
+    if (visited.has(start))
       continue;
+    const component = [];
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const neighbor of reverse.get(current)) {
+        if (visited.has(neighbor))
+          continue;
+        visited.add(neighbor);
+        stack.push(neighbor);
+      }
     }
-    if (state.value.length >= limit) {
-      state.truncated = true;
-      return true;
-    }
-    state.value.push(neighbor);
+    components.push(component);
   }
-  return false;
+  return sortComponents(components);
 }
-function boundedSemanticWalk(graph, start, options, family, matches) {
-  if (!graph.hasNode(start))
-    throw new TypeError(`Relationship node not found: ${start}`);
-  const familyKinds = resolveFamilyKinds(graph, options.kinds, family);
-  const limit = options.limit ?? Number.POSITIVE_INFINITY;
-  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
-  const after = options.after;
-  const state = {
-    seen: /* @__PURE__ */ new Set([start]),
-    value: [],
-    queue: [{ id: start, depth: 0 }],
-    resumed: after === void 0,
-    truncated: false
-  };
-  let visitedNodes = 0;
-  let inspectedEdges = 0;
-  for (let index = 0; index < state.queue.length; index += 1) {
-    options.signal?.throwIfAborted();
-    const current = state.queue[index];
-    visitedNodes += 1;
-    const expansion = expandSemanticNeighbors(graph, current.id, familyKinds, family, matches);
-    inspectedEdges += expansion.inspectedEdges;
-    if (appendSemanticExpansion(expansion, current.depth, maxDepth, limit, after, state))
-      break;
-  }
-  if (!state.resumed)
-    throw new TypeError(`Traversal cursor not found in sequence: ${after}`);
-  return {
-    value: state.value,
-    meta: {
-      visitedNodes,
-      inspectedEdges,
-      truncated: state.truncated,
-      nextCursor: state.value.at(-1)
-    }
-  };
+function stronglyConnectedComponents(nodes, adjacency) {
+  const reverse = createAdjacency(nodes);
+  for (const [source, targets] of adjacency)
+    for (const target of targets)
+      appendNeighbor(reverse, target, source);
+  return collectReverseComponents(computeFinishingOrder(nodes, adjacency), reverse);
 }
-function assertPathEndpoint(graph, id) {
-  if (!graph.hasNode(id))
-    throw new TypeError(`Relationship node not found: ${id}`);
+function buildExecutionAdjacency(graph, registry) {
+  const adjacency = createAdjacency(graph.nodes());
+  for (const edge of graph.edges()) {
+    const definition = registry.require(edge.kind);
+    if (!definition.ordering)
+      continue;
+    const sourceFirst = (definition.precedence ?? "source_before_target") === "source_before_target";
+    appendNeighbor(adjacency, sourceFirst ? edge.source : edge.target, sourceFirst ? edge.target : edge.source);
+  }
+  return adjacency;
 }
-function readPathContinuations(graph, partial, options, direction, state) {
-  const rows = graph.neighborEdges(partial.nodes.at(-1), {
-    direction,
-    ...options.kinds === void 0 ? {} : { kinds: options.kinds }
-  });
-  state.inspectedEdges += rows.meta.inspectedEdges;
-  return rows.value.filter((row) => !partial.nodeSet.has(row.id));
-}
-function expandPartialPath(graph, partial, target, options, direction, probeLimit, state) {
-  for (const row of readPathContinuations(graph, partial, options, direction, state)) {
-    const nodes = [...partial.nodes, row.id];
-    const nodeSet = new Set(partial.nodeSet).add(row.id);
-    const edges = [...partial.edges, row.edge];
-    if (row.id === target) {
-      state.value.push({ nodes, edges, length: edges.length });
-      if (state.value.length >= probeLimit)
-        return true;
-    } else {
-      state.queue.push({ nodes, nodeSet, edges });
+function topologicalLayers(nodes, adjacency) {
+  const indegree = new Map(nodes.map((node) => [node, 0]));
+  for (const targets of adjacency.values())
+    for (const target of targets)
+      indegree.set(target, indegree.get(target) + 1);
+  let frontier = nodes.filter((node) => indegree.get(node) === 0).sort();
+  const layers = [];
+  while (frontier.length > 0) {
+    layers.push(frontier);
+    const next = [];
+    for (const source of frontier) {
+      for (const target of adjacency.get(source)) {
+        const remaining = indegree.get(target) - 1;
+        indegree.set(target, remaining);
+        if (remaining === 0)
+          next.push(target);
+      }
     }
+    frontier = next.sort();
   }
-  return false;
-}
-function hierarchyAncestors(graph, id, options = {}) {
-  return boundedSemanticWalk(graph, id, options, "hierarchy", (row, definition) => hierarchyParentEndpoint(row.edge, definition) === row.id);
-}
-function hierarchyDescendants(graph, id, options = {}) {
-  return boundedSemanticWalk(graph, id, options, "hierarchy", (row, definition, nodeId) => hierarchyParentEndpoint(row.edge, definition) === nodeId);
-}
-function orderingPredecessors(graph, id, options = {}) {
-  return boundedSemanticWalk(graph, id, options, "ordering", (row, definition) => orderingPredecessorEndpoint(row.edge, definition) === row.id);
-}
-function orderingSuccessors(graph, id, options = {}) {
-  return boundedSemanticWalk(graph, id, options, "ordering", (row, definition, nodeId) => orderingPredecessorEndpoint(row.edge, definition) === nodeId);
+  return layers;
 }
-function enumerateNonZeroRelationshipPaths(graph, source, target, options, maxPaths, maxVisitedPaths, maxDepth, direction) {
-  const state = {
-    value: [],
-    queue: [{ nodes: [source], nodeSet: /* @__PURE__ */ new Set([source]), edges: [] }],
-    inspectedEdges: 0
+function longestPath(order, adjacency) {
+  const depth = new Map(order.map((node) => [node, 0]));
+  const parent = /* @__PURE__ */ new Map();
+  for (const source of order) {
+    for (const target of adjacency.get(source)) {
+      if (!depth.has(target))
+        continue;
+      const candidate = depth.get(source) + 1;
+      const currentParent = parent.get(target);
+      if (candidate > depth.get(target) || candidate === depth.get(target) && (currentParent === void 0 || source.localeCompare(currentParent) < 0)) {
+        depth.set(target, candidate);
+        parent.set(target, source);
+      }
+    }
+  }
+  const end = [...order].sort((left, right) => depth.get(right) - depth.get(left) || left.localeCompare(right))[0];
+  const path4 = end === void 0 ? [] : [end];
+  while (path4[0] !== void 0 && parent.has(path4[0]))
+    path4.unshift(parent.get(path4[0]));
+  return { depth: Object.fromEntries(depth), path: path4 };
+}
+function reconstructImpactPath(root, target, parents) {
+  const path4 = [target];
+  let cursor = target;
+  while (cursor !== root) {
+    cursor = parents.get(cursor);
+    path4.push(cursor);
+  }
+  return path4.reverse();
+}
+function analyzeRelationshipExecution(graph, options = {}) {
+  const registry = options.registry ?? createRelationshipKindRegistry();
+  const nodes = [...graph.nodes()];
+  const adjacency = buildExecutionAdjacency(graph, registry);
+  const layers = topologicalLayers(nodes, adjacency);
+  const order = layers.flat();
+  const acyclic = order.length === nodes.length;
+  const cycles = acyclic ? [] : stronglyConnectedComponents(nodes, adjacency).filter((component) => component.length > 1 || adjacency.get(component[0]).has(component[0]));
+  const longest = longestPath(order, adjacency);
+  return {
+    exact: true,
+    acyclic,
+    order,
+    layers,
+    frontier: layers[0] ?? [],
+    depth: longest.depth,
+    criticalPath: longest.path,
+    criticalPathLength: Math.max(0, longest.path.length - 1),
+    cycles,
+    provenance: { algorithm: "kahn-longest-path", edgeFamily: "ordering" }
   };
+}
+function analyzeGraphImpact(graph, root, options = {}) {
+  const direction = options.direction ?? "outgoing";
+  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const queue = [{ id: root, depth: 0 }];
+  const seen = /* @__PURE__ */ new Set([root]);
+  const parents = /* @__PURE__ */ new Map();
+  const affected = [];
   let visitedNodes = 0;
+  let inspectedEdges = 0;
   let truncated = false;
-  const probeLimit = maxPaths + 1;
-  for (let index = 0; index < state.queue.length; index += 1) {
+  traversal: for (let index = 0; index < queue.length; index += 1) {
     options.signal?.throwIfAborted();
-    if (state.value.length >= probeLimit || visitedNodes >= maxVisitedPaths) {
-      truncated = true;
-      break;
-    }
-    const partial = state.queue[index];
+    const current = queue[index];
     visitedNodes += 1;
-    if (partial.edges.length >= maxDepth) {
-      if (readPathContinuations(graph, partial, options, direction, state).length > 0)
+    const adjacent = graph.adjacency(current.id, {
+      direction,
+      kinds: options.kinds,
+      signal: options.signal
+    });
+    inspectedEdges += adjacent.meta.inspectedEdges;
+    if (current.depth >= maxDepth) {
+      if (adjacent.value.some((id) => !seen.has(id)))
         truncated = true;
       continue;
     }
-    if (expandPartialPath(graph, partial, target, options, direction, probeLimit, state)) {
-      truncated = true;
-      break;
+    for (const id of adjacent.value) {
+      if (seen.has(id))
+        continue;
+      if (affected.length >= limit) {
+        truncated = true;
+        break traversal;
+      }
+      seen.add(id);
+      parents.set(id, current.id);
+      const depth = current.depth + 1;
+      affected.push({
+        id,
+        distance: depth,
+        path: reconstructImpactPath(root, id, parents)
+      });
+      queue.push({ id, depth });
     }
   }
   return {
-    value: state.value.slice(0, maxPaths),
-    meta: { visitedNodes, inspectedEdges: state.inspectedEdges, truncated }
+    root,
+    affected,
+    exact: true,
+    truncated,
+    cost: { visitedNodes, inspectedEdges }
   };
 }
-function enumerateRelationshipPaths(graph, source, target, options = {}) {
-  assertPathEndpoint(graph, source);
-  assertPathEndpoint(graph, target);
-  const maxPaths = options.maxPaths ?? DEFAULT_MAX_PATHS;
-  const maxVisitedPaths = options.maxVisitedPaths ?? DEFAULT_MAX_VISITED_PATHS;
-  const maxDepth = options.maxDepth ?? DEFAULT_PATH_MAX_DEPTH;
-  assertPathBound("maxPaths", maxPaths);
-  assertPathBound("maxVisitedPaths", maxVisitedPaths);
-  assertPathBound("maxDepth", maxDepth);
-  const direction = options.direction ?? "outgoing";
-  options.signal?.throwIfAborted();
-  for (const kind of options.kinds ?? [])
-    graph.registry().require(kind);
-  if (source === target) {
-    if (maxPaths === 0) {
-      return {
-        value: [],
-        meta: { visitedNodes: 1, inspectedEdges: 0, truncated: true }
-      };
-    }
-    return {
-      value: [{ nodes: [source], edges: [], length: 0 }],
-      meta: { visitedNodes: 1, inspectedEdges: 0, truncated: false }
-    };
-  }
-  return enumerateNonZeroRelationshipPaths(graph, source, target, options, maxPaths, maxVisitedPaths, maxDepth, direction);
-}
-
-// dist/sdk/graph/analytics.js
-var DEFAULT_MAX_ITERATIONS = 16;
-var DEFAULT_MIN_COMMUNITY_SIZE = 2;
-var DEFAULT_REDUNDANCY_MAX_DEPTH = 8;
-function assertPositiveBound(name, value) {
-  if (!Number.isInteger(value) || value < 1)
-    throw new TypeError(`Invalid ${name} bound: ${String(value)}`);
-}
-function buildUndirectedAdjacency(graph, kinds) {
-  const registry = graph.registry();
-  const wanted = kinds === void 0 ? void 0 : new Set(kinds.map((kind) => registry.require(kind).kind));
-  const adjacency = /* @__PURE__ */ new Map();
+function analyzeKnowledgeGraph(graph) {
+  const nodes = [...graph.nodes()];
+  const weak = createAdjacency(nodes);
+  const directed = createAdjacency(nodes);
   for (const edge of graph.edges()) {
-    if (edge.source === edge.target)
-      continue;
-    if (wanted !== void 0) {
-      const definition = registry.require(edge.kind);
-      const matches = wanted.has(definition.kind) || definition.inverse !== void 0 && wanted.has(definition.inverse);
-      if (!matches)
-        continue;
-    }
-    appendAdjacency(adjacency, edge.source, edge.target);
-    appendAdjacency(adjacency, edge.target, edge.source);
-  }
-  for (const neighbors of adjacency.values())
-    neighbors.sort();
-  return adjacency;
-}
-function appendAdjacency(adjacency, from, to) {
-  const neighbors = adjacency.get(from);
-  if (neighbors === void 0)
-    adjacency.set(from, [to]);
-  else
-    neighbors.push(to);
-}
-function dominantNeighborLabel(neighbors, labels) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const neighbor of neighbors) {
-    const label = labels.get(neighbor);
-    counts.set(label, (counts.get(label) ?? 0) + 1);
-  }
-  let best;
-  let bestCount = 0;
-  for (const [label, count] of counts) {
-    if (count > bestCount || count === bestCount && label < best) {
-      best = label;
-      bestCount = count;
-    }
-  }
-  return best;
-}
-function collectCommunities(labels, minSize) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [id, label] of labels) {
-    const members = groups.get(label);
-    if (members === void 0)
-      groups.set(label, [id]);
-    else
-      members.push(id);
-  }
-  const communities = [];
-  for (const members of groups.values()) {
-    if (members.length < minSize)
+    appendNeighbor(weak, edge.source, edge.target);
+    appendNeighbor(weak, edge.target, edge.source);
+    appendNeighbor(directed, edge.source, edge.target);
+  }
+  const components = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const start of nodes) {
+    if (visited.has(start))
       continue;
-    members.sort();
-    communities.push({
-      representative: members[0],
-      size: members.length,
-      members
-    });
-  }
-  return communities.sort((left, right) => right.size - left.size || left.representative.localeCompare(right.representative));
-}
-function detectRelationshipCommunities(graph, options = {}) {
-  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
-  const minSize = options.minSize ?? DEFAULT_MIN_COMMUNITY_SIZE;
-  assertPositiveBound("maxIterations", maxIterations);
-  assertPositiveBound("minSize", minSize);
-  const adjacency = buildUndirectedAdjacency(graph, options.kinds);
-  const nodes = graph.nodes();
-  const labels = new Map(nodes.map((id) => [id, id]));
-  let iterations = 0;
-  let converged = false;
-  let visitedNodes = 0;
-  let inspectedEdges = 0;
-  while (iterations < maxIterations && !converged) {
-    options.signal?.throwIfAborted();
-    iterations += 1;
-    converged = true;
-    for (const id of nodes) {
-      visitedNodes += 1;
-      const neighbors = adjacency.get(id);
-      if (neighbors === void 0)
-        continue;
-      inspectedEdges += neighbors.length;
-      const dominant = dominantNeighborLabel(neighbors, labels);
-      if (dominant !== labels.get(id)) {
-        labels.set(id, dominant);
-        converged = false;
+    const component = [];
+    const stack = [start];
+    visited.add(start);
+    while (stack.length > 0) {
+      const current = stack.pop();
+      component.push(current);
+      for (const neighbor of weak.get(current)) {
+        if (visited.has(neighbor))
+          continue;
+        visited.add(neighbor);
+        stack.push(neighbor);
       }
     }
+    components.push(component);
   }
+  const degrees = nodes.map((id) => ({ id, degree: weak.get(id).size }));
+  const maximum = Math.max(0, ...degrees.map(({ degree }) => degree));
   return {
-    value: {
-      communities: collectCommunities(labels, minSize),
-      iterations,
-      converged
-    },
-    meta: { visitedNodes, inspectedEdges, truncated: !converged }
+    components: sortComponents(components),
+    stronglyConnected: stronglyConnectedComponents(nodes, directed),
+    orphans: degrees.filter(({ degree }) => degree === 0).map(({ id }) => id),
+    hubs: degrees.filter(({ degree }) => degree > 0 && degree === maximum),
+    exact: true,
+    provenance: { algorithm: "component-degree", edgeFamily: "all" }
   };
 }
-function isTransitiveKind(definition) {
-  return definition.direction === "directed" && (definition.ordering || definition.hierarchy);
+function compareRelationshipSnapshots(before, after) {
+  const earlier = new Map(before.edges.map((edge) => [relationshipEdgeKey(edge), edge]));
+  const later = new Map(after.edges.map((edge) => [relationshipEdgeKey(edge), edge]));
+  return {
+    fromVersion: before.version,
+    toVersion: after.version,
+    added: [...later].filter(([key]) => !earlier.has(key)).map(([, edge]) => edge),
+    removed: [...earlier].filter(([key]) => !later.has(key)).map(([, edge]) => edge),
+    unchangedCount: [...earlier.keys()].filter((key) => later.has(key)).length,
+    exact: true
+  };
 }
-function transitiveFamilyKey(definition) {
-  return definition.inverse !== void 0 && definition.inverse < definition.kind ? definition.inverse : definition.kind;
+
+// dist/sdk/graph/centrality.js
+function roundScore(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+function addToSetMap(map, key, value) {
+  const set = map.get(key);
+  if (set === void 0)
+    map.set(key, /* @__PURE__ */ new Set([value]));
+  else
+    set.add(value);
 }
-function orientTransitiveEdge(edge, definition) {
-  const head = definition.hierarchy ? hierarchyParentEndpoint(edge, definition) : edge.source === orderingPredecessorEndpoint(edge, definition) ? edge.target : edge.source;
-  return head === edge.target ? { from: edge.source, to: edge.target } : { from: edge.target, to: edge.source };
+function buildSimpleUndirectedAdjacency(graph, kinds) {
+  const sets = new Map(graph.nodes().map((id) => [id, /* @__PURE__ */ new Set()]));
+  forEachMatchedRelationshipEdge(graph, kinds, (edge) => {
+    sets.get(edge.source).add(edge.target);
+    sets.get(edge.target).add(edge.source);
+  });
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const [id, neighbors] of sets)
+    adjacency.set(id, [...neighbors].sort());
+  return adjacency;
 }
-function resolveRedundancyFamilies(graph, kinds) {
-  if (kinds === void 0)
-    return void 0;
-  const registry = graph.registry();
-  const families = /* @__PURE__ */ new Set();
-  for (const kind of kinds) {
-    const definition = registry.require(kind);
-    if (!isTransitiveKind(definition))
-      throw new TypeError(`Relationship kind ${definition.kind} is not a directed ordering or hierarchy kind`);
-    families.add(transitiveFamilyKey(definition));
+function collectOrderingDegrees(graph, kinds) {
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  forEachMatchedRelationshipEdge(graph, kinds, (edge, definition) => {
+    if (!definition.ordering)
+      return;
+    const { predecessor, successor } = orientOrderingEdge(edge, definition);
+    addToSetMap(outgoing, predecessor, successor);
+    addToSetMap(incoming, successor, predecessor);
+  });
+  return { incoming, outgoing };
+}
+function brandesShortestPaths(source, adjacency, cost) {
+  const distance = /* @__PURE__ */ new Map([[source, 0]]);
+  const sigma = /* @__PURE__ */ new Map([[source, 1]]);
+  const predecessors = /* @__PURE__ */ new Map();
+  const stack = [];
+  const queue = [source];
+  let reachableCount = 0;
+  let distanceSum = 0;
+  for (let index = 0; index < queue.length; index += 1) {
+    const node = queue[index];
+    cost.visitedNodes += 1;
+    stack.push(node);
+    const nodeDistance = distance.get(node);
+    if (node !== source) {
+      reachableCount += 1;
+      distanceSum += nodeDistance;
+    }
+    for (const neighbor of adjacency.get(node)) {
+      cost.inspectedEdges += 1;
+      if (!distance.has(neighbor)) {
+        distance.set(neighbor, nodeDistance + 1);
+        queue.push(neighbor);
+      }
+      if (distance.get(neighbor) === nodeDistance + 1) {
+        sigma.set(neighbor, (sigma.get(neighbor) ?? 0) + sigma.get(node));
+        const predecessorList = predecessors.get(neighbor);
+        if (predecessorList === void 0)
+          predecessors.set(neighbor, [node]);
+        else
+          predecessorList.push(node);
+      }
+    }
   }
-  return families;
+  return { stack, sigma, predecessors, reachableCount, distanceSum };
 }
-function collectTransitiveFamilies(graph, wanted) {
-  const registry = graph.registry();
-  const families = /* @__PURE__ */ new Map();
-  for (const edge of graph.edges()) {
-    const definition = registry.require(edge.kind);
-    if (!isTransitiveKind(definition))
-      continue;
-    const key = transitiveFamilyKey(definition);
-    if (wanted !== void 0 && !wanted.has(key))
-      continue;
-    const oriented = orientTransitiveEdge(edge, definition);
-    if (oriented.from === oriented.to)
-      continue;
-    let family = families.get(key);
-    if (family === void 0) {
-      family = { adjacency: /* @__PURE__ */ new Map(), records: [] };
-      families.set(key, family);
+function accumulateBetweenness(sweep, source, betweenness) {
+  const dependency = /* @__PURE__ */ new Map();
+  for (let index = sweep.stack.length - 1; index >= 0; index -= 1) {
+    const node = sweep.stack[index];
+    const share = (1 + (dependency.get(node) ?? 0)) / sweep.sigma.get(node);
+    for (const predecessor of sweep.predecessors.get(node) ?? []) {
+      dependency.set(predecessor, (dependency.get(predecessor) ?? 0) + sweep.sigma.get(predecessor) * share);
     }
-    const targets = family.adjacency.get(oriented.from);
-    if (targets === void 0)
-      family.adjacency.set(oriented.from, /* @__PURE__ */ new Set([oriented.to]));
-    else
-      targets.add(oriented.to);
-    family.records.push({ ...oriented, edge });
-  }
-  return families;
-}
-function sortedFamilyAdjacency(family) {
-  const sorted = /* @__PURE__ */ new Map();
-  for (const [from, targets] of family.adjacency)
-    sorted.set(from, [...targets].sort());
-  return sorted;
-}
-function reconstructWitness(parents, from, tail, head) {
-  const witness = [head];
-  for (let node = tail; node !== from; node = parents.get(node))
-    witness.push(node);
-  witness.push(from);
-  return witness.reverse();
-}
-function expandWitnessFrontier(adjacency, record, current, parents, queue, cost) {
-  for (const next of adjacency.get(current.id) ?? []) {
-    cost.inspectedEdges += 1;
-    if (current.depth === 0 && next === record.to)
-      continue;
-    if (parents.has(next))
-      continue;
-    parents.set(next, current.id);
-    if (next === record.to)
-      return reconstructWitness(parents, record.from, current.id, next);
-    queue.push({ id: next, depth: current.depth + 1 });
+    if (node !== source)
+      betweenness.set(node, (betweenness.get(node) ?? 0) + (dependency.get(node) ?? 0));
   }
-  return void 0;
 }
-function findWitnessPath(adjacency, record, maxDepth, cost) {
-  const parents = /* @__PURE__ */ new Map([[record.from, record.from]]);
-  const queue = [{ id: record.from, depth: 0 }];
-  for (let index = 0; index < queue.length; index += 1) {
-    const current = queue[index];
-    cost.visitedNodes += 1;
-    if (current.depth >= maxDepth)
-      continue;
-    const witness = expandWitnessFrontier(adjacency, record, current, parents, queue, cost);
-    if (witness !== void 0)
-      return witness;
-  }
-  return void 0;
+function wassermanFaustCloseness(sweep, nodeCount) {
+  if (nodeCount <= 1 || sweep.reachableCount === 0)
+    return 0;
+  return sweep.reachableCount / (nodeCount - 1) * (sweep.reachableCount / sweep.distanceSum);
 }
-function findRedundantRelationshipEdges(graph, options = {}) {
-  const maxDepth = options.maxDepth ?? DEFAULT_REDUNDANCY_MAX_DEPTH;
-  assertPositiveBound("maxDepth", maxDepth);
-  if (options.limit !== void 0)
-    assertPositiveBound("limit", options.limit);
-  const limit = options.limit ?? Number.POSITIVE_INFINITY;
-  const wanted = resolveRedundancyFamilies(graph, options.kinds);
-  const families = collectTransitiveFamilies(graph, wanted);
-  const value = [];
+function centralityRow(id, adjacency, directed, betweenness, closeness) {
+  return {
+    id,
+    degree: adjacency.get(id).length,
+    inDegree: directed.incoming.get(id)?.size ?? 0,
+    outDegree: directed.outgoing.get(id)?.size ?? 0,
+    // Undirected betweenness double-counts each ordered pair; halve it.
+    betweenness: roundScore((betweenness.get(id) ?? 0) / 2),
+    // Every node is a sweep source, so closeness is always populated.
+    closeness: roundScore(closeness.get(id))
+  };
+}
+function computeRelationshipCentrality(graph, options = {}) {
+  const adjacency = buildSimpleUndirectedAdjacency(graph, options.kinds);
+  const directed = collectOrderingDegrees(graph, options.kinds);
+  const nodes = graph.nodes();
+  const betweenness = /* @__PURE__ */ new Map();
+  const closeness = /* @__PURE__ */ new Map();
   const cost = { visitedNodes: 0, inspectedEdges: 0 };
-  let truncated = false;
-  scan: for (const key of [...families.keys()].sort()) {
-    const family = families.get(key);
-    const adjacency = sortedFamilyAdjacency(family);
-    for (const record of family.records) {
-      options.signal?.throwIfAborted();
-      const witness = findWitnessPath(adjacency, record, maxDepth, cost);
-      if (witness === void 0)
-        continue;
-      if (value.length >= limit) {
-        truncated = true;
-        break scan;
-      }
-      value.push({ edge: record.edge, witness });
-    }
+  for (const source of nodes) {
+    options.signal?.throwIfAborted();
+    const sweep = brandesShortestPaths(source, adjacency, cost);
+    closeness.set(source, wassermanFaustCloseness(sweep, nodes.length));
+    accumulateBetweenness(sweep, source, betweenness);
   }
+  let degreeSum = 0;
+  for (const neighbors of adjacency.values())
+    degreeSum += neighbors.length;
+  const rows = nodes.map((id) => centralityRow(id, adjacency, directed, betweenness, closeness)).sort((left, right) => right.betweenness - left.betweenness || right.degree - left.degree || left.id.localeCompare(right.id));
   return {
-    value,
+    value: { nodeCount: nodes.length, edgeCount: degreeSum / 2, rows },
     meta: {
       visitedNodes: cost.visitedNodes,
       inspectedEdges: cost.inspectedEdges,
-      truncated
+      truncated: false
     }
   };
 }
-function expandReachableNode(id, depth, rows, maxDepth, state) {
-  const nextSet = /* @__PURE__ */ new Set();
-  const nexts = [];
-  for (const row of rows) {
-    if (row.id === id || nextSet.has(row.id))
-      continue;
-    if (!state.seen.has(row.id)) {
-      if (depth >= maxDepth) {
-        state.truncated = true;
-        continue;
-      }
-      state.seen.add(row.id);
-      state.queue.push({ id: row.id, depth: depth + 1 });
-    }
-    nextSet.add(row.id);
-    nexts.push(row.id);
-    let incoming = state.predecessors.get(row.id);
-    if (incoming === void 0) {
-      incoming = /* @__PURE__ */ new Set();
-      state.predecessors.set(row.id, incoming);
-    }
-    incoming.add(id);
-  }
-  return nexts;
+function orderedBridge(left, right) {
+  return left <= right ? { source: left, target: right } : { source: right, target: left };
 }
-function indexReachableSubgraph(graph, root, options) {
-  const direction = options.direction ?? "outgoing";
-  const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
-  const order = [];
-  const successors = /* @__PURE__ */ new Map();
-  const state = {
-    seen: /* @__PURE__ */ new Set([root]),
-    queue: [{ id: root, depth: 0 }],
-    predecessors: /* @__PURE__ */ new Map(),
-    truncated: false
-  };
-  let inspectedEdges = 0;
-  for (let index = 0; index < state.queue.length; index += 1) {
-    options.signal?.throwIfAborted();
-    const { id, depth } = state.queue[index];
-    order.push(id);
-    const rows = graph.neighborEdges(id, {
-      direction,
-      ...options.kinds === void 0 ? {} : { kinds: options.kinds }
-    });
-    inspectedEdges += rows.meta.inspectedEdges;
-    successors.set(id, expandReachableNode(id, depth, rows.value, maxDepth, state));
+function advanceCutFrame(frame, adjacency, state) {
+  const neighbors = adjacency.get(frame.node);
+  const neighbor = neighbors[frame.neighborIndex];
+  frame.neighborIndex += 1;
+  state.inspectedEdges += 1;
+  if (neighbor === frame.parent)
+    return void 0;
+  if (state.discovery.has(neighbor)) {
+    state.low.set(frame.node, Math.min(state.low.get(frame.node), state.discovery.get(neighbor)));
+    return void 0;
   }
-  return {
-    order,
-    successors,
-    predecessors: state.predecessors,
-    inspectedEdges,
-    truncated: state.truncated
-  };
+  frame.children += 1;
+  state.discovery.set(neighbor, state.timer);
+  state.low.set(neighbor, state.timer);
+  state.timer += 1;
+  return { node: neighbor, parent: frame.node, neighborIndex: 0, children: 0 };
 }
-function reversePostorder(subgraph, root) {
-  const postorder = [];
-  const visited = /* @__PURE__ */ new Set([root]);
-  const stack = [{ id: root, index: 0 }];
+function retreatCutFrame(frame, root, state) {
+  if (frame.parent === null) {
+    if (frame.children > 1)
+      state.articulation.add(frame.node);
+    return;
+  }
+  const parent = frame.parent;
+  const childLow = state.low.get(frame.node);
+  state.low.set(parent, Math.min(state.low.get(parent), childLow));
+  if (parent !== root && childLow >= state.discovery.get(parent))
+    state.articulation.add(parent);
+  if (childLow > state.discovery.get(parent))
+    state.bridges.push(orderedBridge(parent, frame.node));
+}
+function searchComponentCuts(root, adjacency, state, signal) {
+  state.discovery.set(root, state.timer);
+  state.low.set(root, state.timer);
+  state.timer += 1;
+  const stack = [
+    { node: root, parent: null, neighborIndex: 0, children: 0 }
+  ];
   while (stack.length > 0) {
+    signal?.throwIfAborted();
     const frame = stack.at(-1);
-    const nexts = subgraph.successors.get(frame.id);
-    if (frame.index < nexts.length) {
-      const next = nexts[frame.index];
-      frame.index += 1;
-      if (!visited.has(next)) {
-        visited.add(next);
-        stack.push({ id: next, index: 0 });
-      }
+    if (frame.neighborIndex < adjacency.get(frame.node).length) {
+      const child = advanceCutFrame(frame, adjacency, state);
+      if (child !== void 0)
+        stack.push(child);
     } else {
-      postorder.push(frame.id);
+      retreatCutFrame(frame, root, state);
       stack.pop();
     }
   }
-  return postorder.reverse();
 }
-function intersectDominators(left, right, idom, ordinal) {
-  let first = left;
-  let second = right;
-  while (first !== second) {
-    while (ordinal.get(first) > ordinal.get(second))
-      first = idom.get(first);
-    while (ordinal.get(second) > ordinal.get(first))
-      second = idom.get(second);
-  }
-  return first;
-}
-function dominatorCandidate(predecessors, idom, ordinal) {
-  let candidate;
-  for (const pred of [...predecessors].sort()) {
-    if (!idom.has(pred))
-      continue;
-    candidate = candidate === void 0 ? pred : intersectDominators(candidate, pred, idom, ordinal);
-  }
-  return candidate;
-}
-function solveImmediateDominators(subgraph, root, order, ordinal, signal) {
-  const idom = /* @__PURE__ */ new Map([[root, root]]);
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const id of order) {
-      signal?.throwIfAborted();
-      if (id === root)
-        continue;
-      const candidate = dominatorCandidate(subgraph.predecessors.get(id), idom, ordinal);
-      if (candidate !== void 0 && idom.get(id) !== candidate) {
-        idom.set(id, candidate);
-        changed = true;
-      }
-    }
-  }
-  return idom;
-}
-function computeRelationshipDominators(graph, root, options = {}) {
-  if (!graph.hasNode(root))
-    throw new TypeError(`Relationship node not found: ${root}`);
-  if (options.maxDepth !== void 0 && (!Number.isInteger(options.maxDepth) || options.maxDepth < 0))
-    throw new TypeError(`Invalid maxDepth bound: ${String(options.maxDepth)}`);
-  const subgraph = indexReachableSubgraph(graph, root, options);
-  const order = reversePostorder(subgraph, root);
-  const ordinal = new Map(order.map((id, index) => [id, index]));
-  const idom = solveImmediateDominators(subgraph, root, order, ordinal, options.signal);
-  const subtreeSizes = new Map(order.map((id) => [id, 1]));
-  for (let index = order.length - 1; index >= 0; index -= 1) {
-    const id = order[index];
-    if (id === root)
+function findRelationshipCutStructure(graph, options = {}) {
+  const adjacency = buildSimpleUndirectedAdjacency(graph, options.kinds);
+  const state = {
+    discovery: /* @__PURE__ */ new Map(),
+    low: /* @__PURE__ */ new Map(),
+    timer: 0,
+    articulation: /* @__PURE__ */ new Set(),
+    bridges: [],
+    inspectedEdges: 0
+  };
+  for (const root of graph.nodes()) {
+    if (state.discovery.has(root))
       continue;
-    const parent = idom.get(id);
-    subtreeSizes.set(parent, subtreeSizes.get(parent) + subtreeSizes.get(id));
+    searchComponentCuts(root, adjacency, state, options.signal);
   }
-  const rows = order.filter((id) => id !== root).map((id) => ({
-    id,
-    idom: idom.get(id),
-    dominatedCount: subtreeSizes.get(id) - 1
-  })).sort((left, right) => right.dominatedCount - left.dominatedCount || left.id.localeCompare(right.id));
   return {
-    value: { root, reachableCount: subgraph.order.length, rows },
+    value: {
+      articulationPoints: [...state.articulation].sort(),
+      bridges: state.bridges.sort((left, right) => left.source.localeCompare(right.source) || left.target.localeCompare(right.target))
+    },
     meta: {
-      visitedNodes: subgraph.order.length,
-      inspectedEdges: subgraph.inspectedEdges,
-      truncated: subgraph.truncated
+      visitedNodes: state.discovery.size,
+      inspectedEdges: state.inspectedEdges,
+      truncated: false
     }
   };
 }
 
-// dist/sdk/graph/governance.js
-var DEFAULT_MAX_SAMPLE_SIZE = 25;
-var SEVERITY_RANK = {
-  error: 0,
-  warning: 1,
-  info: 2
-};
-function buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation) {
-  const sorted = [...subjects].sort((left, right) => left.localeCompare(right));
-  return {
-    code,
-    severity,
-    policy,
-    message: describe(sorted.length),
-    count: sorted.length,
-    sample: sorted.slice(0, maxSampleSize),
-    sample_truncated: sorted.length > maxSampleSize,
-    remediation
-  };
-}
-function buildOrderingAdjacency(assembly) {
-  const registry = assembly.graph.registry();
-  const successors = /* @__PURE__ */ new Map();
-  for (const edge of assembly.graph.edges()) {
+// dist/sdk/graph/scheduling.js
+function collectOrderingParticipation(graph) {
+  const registry = graph.registry();
+  const forward = /* @__PURE__ */ new Map();
+  const participants = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges()) {
     const definition = registry.require(edge.kind);
     if (!definition.ordering)
       continue;
-    const [predecessor, successor] = (definition.precedence ?? "source_before_target") === "target_before_source" ? [edge.target, edge.source] : [edge.source, edge.target];
-    const adjacent = successors.get(predecessor);
-    if (adjacent)
-      adjacent.push(successor);
+    const { predecessor, successor } = orientOrderingEdge(edge, definition);
+    participants.add(predecessor);
+    participants.add(successor);
+    if (predecessor === successor)
+      continue;
+    const targets = forward.get(predecessor);
+    if (targets === void 0)
+      forward.set(predecessor, /* @__PURE__ */ new Set([successor]));
     else
-      successors.set(predecessor, [successor]);
-  }
-  for (const adjacent of successors.values())
-    adjacent.sort((left, right) => left.localeCompare(right));
-  return successors;
-}
-function registerTarjanNode(node, state) {
-  state.indexes.set(node, state.nextIndex);
-  state.lowLinks.set(node, state.nextIndex);
-  state.nextIndex += 1;
-  state.stack.push(node);
-  state.onStack.add(node);
-}
-function visitNextTarjanNeighbor(frame, frames, successors, state) {
-  const neighbors = successors.get(frame.node) ?? [];
-  if (frame.neighborIndex >= neighbors.length)
-    return false;
-  const neighbor = neighbors[frame.neighborIndex];
-  frame.neighborIndex += 1;
-  if (!state.indexes.has(neighbor)) {
-    registerTarjanNode(neighbor, state);
-    frames.push({ node: neighbor, neighborIndex: 0 });
-  } else if (state.onStack.has(neighbor)) {
-    state.lowLinks.set(frame.node, Math.min(state.lowLinks.get(frame.node), state.indexes.get(neighbor)));
+      targets.add(successor);
   }
-  return true;
+  return { forward, participants };
 }
-function completeTarjanFrame(frame, frames, successors, state) {
-  frames.pop();
-  const parent = frames.at(-1);
-  if (parent)
-    state.lowLinks.set(parent.node, Math.min(state.lowLinks.get(parent.node), state.lowLinks.get(frame.node)));
-  if (state.lowLinks.get(frame.node) !== state.indexes.get(frame.node))
-    return;
-  const component = [];
-  while (true) {
-    const member = state.stack.pop();
-    state.onStack.delete(member);
-    component.push(member);
-    if (member === frame.node)
-      break;
+function latestFinishFor(successors, acyclic, latestStart, makespan) {
+  if (successors === void 0)
+    return makespan;
+  let bound = makespan;
+  for (const successor of successors) {
+    if (!acyclic.has(successor))
+      continue;
+    bound = Math.min(bound, latestStart.get(successor));
   }
-  if (component.length > 1 || component.length === 1 && successors.get(component[0])?.includes(component[0]))
-    state.components.push(component.sort((left, right) => left.localeCompare(right)));
+  return bound;
 }
-function collectOrderingCycles(successors) {
-  const state = {
-    indexes: /* @__PURE__ */ new Map(),
-    lowLinks: /* @__PURE__ */ new Map(),
-    onStack: /* @__PURE__ */ new Set(),
-    stack: [],
-    components: [],
-    nextIndex: 0
+function scheduleRow(id, earliestStart, latestStart) {
+  const slack = latestStart - earliestStart;
+  return {
+    id,
+    earliestStart,
+    earliestFinish: earliestStart + 1,
+    latestStart,
+    latestFinish: latestStart + 1,
+    slack,
+    critical: slack === 0
   };
-  const roots = [...successors.keys()].sort((left, right) => left.localeCompare(right));
-  for (const root of roots) {
-    if (state.indexes.has(root))
-      continue;
-    const frames = [{ node: root, neighborIndex: 0 }];
-    registerTarjanNode(root, state);
-    while (frames.length > 0) {
-      const frame = frames.at(-1);
-      if (visitNextTarjanNeighbor(frame, frames, successors, state))
-        continue;
-      completeTarjanFrame(frame, frames, successors, state);
-    }
-  }
-  return state.components.sort((left, right) => left[0].localeCompare(right[0]));
 }
-function formatDanglingReference(reference) {
-  return `${reference.holder_id} -> ${reference.target_id} (${reference.kind})`;
+function computeScheduleRows(topoParticipants, participation, depth, acyclic, makespan) {
+  const latestStart = /* @__PURE__ */ new Map();
+  for (let index = topoParticipants.length - 1; index >= 0; index -= 1) {
+    const id = topoParticipants[index];
+    const finish = latestFinishFor(participation.forward.get(id), acyclic, latestStart, makespan);
+    latestStart.set(id, finish - 1);
+  }
+  return topoParticipants.map((id) => scheduleRow(id, depth[id], latestStart.get(id))).sort((left, right) => left.slack - right.slack || left.earliestStart - right.earliestStart || left.id.localeCompare(right.id));
 }
-function appendFinding(findings, subjects, maxSampleSize, code, severity, policy, describe, remediation) {
-  if (subjects.length === 0)
-    return;
-  findings.push(buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation));
-}
-function collectIntegrityFindings(assembly, isTerminal, maxSampleSize) {
-  const findings = [];
-  const references = [
-    ...assembly.dangling.active,
-    ...assembly.dangling.legacy_terminal
-  ].filter((reference) => !reference.no_active_blocker_sentinel);
-  appendFinding(findings, references.filter((reference) => !isTerminal(reference.holder_status)).map(formatDanglingReference), maxSampleSize, "missing_reference_active", "error", "Active items must not reference absent targets; missing prerequisites distort scheduling.", (count) => `${count} active dangling reference(s) to absent items`, "Restore or re-create the referenced item, or remove/retype the reference on the holder.");
-  appendFinding(findings, references.filter((reference) => isTerminal(reference.holder_status)).map(formatDanglingReference), maxSampleSize, "missing_reference_terminal", "info", "Terminal items may retain historical references, but absent targets remain unexplainable context.", (count) => `${count} terminal dangling reference(s) to absent items`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
-  appendFinding(findings, assembly.dangling.no_active_blocker_sentinels.map(formatDanglingReference), maxSampleSize, "legacy_no_blocker_sentinel", "info", "The pre-structured-dependency no-active-blocker sentinel is retired; real edges carry blocker state.", (count) => `${count} legacy no-active-blocker sentinel reference(s)`, "Delete the sentinel reference; blocker state is derived from blocked_by edges.");
-  return findings;
-}
-function isActiveAuditMember(member, nodeStates) {
-  const state = nodeStates.get(member);
-  if (!state)
-    return true;
-  return !state.terminal;
-}
-function collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize) {
-  const findings = [];
-  const orderingAdjacency = buildOrderingAdjacency(assembly);
-  for (const cycle of collectOrderingCycles(orderingAdjacency)) {
-    const active = cycle.some((member) => isActiveAuditMember(member, nodeStates));
-    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."));
-  }
-  const predecessorsByNode = /* @__PURE__ */ new Map();
-  for (const [predecessor, adjacent] of orderingAdjacency)
-    for (const successor of adjacent) {
-      const predecessors = predecessorsByNode.get(successor);
-      if (predecessors)
-        predecessors.push(predecessor);
-      else
-        predecessorsByNode.set(successor, [predecessor]);
-    }
-  const staleLifecycleBlocks = [...nodeStates.values()].filter((state) => !state.missing && !state.terminal && isBlocked(state.status) && !(predecessorsByNode.get(state.id) ?? []).some((predecessor) => {
-    const predecessorState = nodeStates.get(predecessor);
-    return predecessorState === void 0 || !predecessorState.terminal;
-  })).map((state) => state.id);
-  appendFinding(findings, staleLifecycleBlocks, maxSampleSize, "stale_lifecycle_block", "warning", "A blocked lifecycle status must be backed by at least one open ordering predecessor.", (count) => `${count} status-blocked item(s) with no open blocker edge`, "Re-open the missing prerequisite as an edge, or move the item back to an active status.");
-  return findings;
-}
-function formatDuplicateEdgeGroup(group) {
-  const kinds = group.edges.map((edge) => edge.kind).sort((left, right) => left.localeCompare(right));
-  return `${group.from} -> ${group.to} (${kinds.join(" + ")})`;
-}
-function collectDuplicateRelationshipEdgeGroups(assembly) {
-  const registry = assembly.graph.registry();
-  const groups = /* @__PURE__ */ new Map();
-  for (const edge of assembly.graph.edges()) {
-    const definition = registry.require(edge.kind);
-    if (!isTransitiveKind(definition))
-      continue;
-    const oriented = orientTransitiveEdge(edge, definition);
-    if (oriented.from === oriented.to)
-      continue;
-    const key = `${transitiveFamilyKey(definition)}::${oriented.from}::${oriented.to}`;
-    const group = groups.get(key);
-    if (group)
-      group.edges.push(edge);
-    else
-      groups.set(key, { ...oriented, edges: [edge] });
-  }
-  const duplicated = [...groups.values()].filter((group) => group.edges.length >= 2);
-  for (const group of duplicated)
-    group.edges.sort((left, right) => left.kind.localeCompare(right.kind));
-  return duplicated.sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to));
-}
-function collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize) {
-  const active = [];
-  const legacy = [];
-  for (const group of collectDuplicateRelationshipEdgeGroups(assembly)) {
-    const subjects = isActiveAuditMember(group.from, nodeStates) || isActiveAuditMember(group.to, nodeStates) ? active : legacy;
-    subjects.push(formatDuplicateEdgeGroup(group));
-  }
-  const findings = [];
-  appendFinding(findings, active, maxSampleSize, "duplicate_edge", "info", "One semantic relationship should be stored once; parallel same-family spellings (reciprocal inverse pairs included) add no information and skew degree metrics.", (count) => `${count} duplicated relationship(s) between active endpoints`, "Remove all but one stored spelling of the relationship; keep the canonical direction the holder declared first.");
-  appendFinding(findings, legacy, maxSampleSize, "legacy_duplicate_edge", "info", "Duplicated spellings between exclusively terminal items are historical noise with no scheduling effect.", (count) => `${count} duplicated relationship(s) between terminal endpoints`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
-  return findings;
-}
-function collectCoverageReport(assembly, nodeStates, exemptIsolates, maxSampleSize, edgesByKind) {
-  let activeNodes = 0;
-  let missingNodes = 0;
-  let isolatedActiveNodes = 0;
-  let degreeLeqOneActive = 0;
-  const isolates = [];
-  const sparse = [];
-  for (const id of assembly.graph.nodes()) {
-    const state = nodeStates.get(id);
-    if (!state)
-      continue;
-    if (state.missing) {
-      missingNodes += 1;
-      continue;
+function analyzeRelationshipSchedule(graph, options = {}) {
+  options.signal?.throwIfAborted();
+  const execution = analyzeRelationshipExecution(graph, { registry: graph.registry() });
+  const participation = collectOrderingParticipation(graph);
+  const acyclic = new Set(execution.order);
+  const topoParticipants = execution.order.filter((id) => participation.participants.has(id));
+  const makespan = topoParticipants.reduce((peak, id) => Math.max(peak, execution.depth[id] + 1), 0);
+  const rows = computeScheduleRows(topoParticipants, participation, execution.depth, acyclic, makespan);
+  const scheduled = rows.length > 0;
+  return {
+    exact: true,
+    acyclic: execution.acyclic,
+    makespan,
+    scheduledCount: rows.length,
+    // A single-node execution "path" over a workspace with no order-bearing
+    // edge is not a real critical path, so report it only when work is scheduled.
+    criticalPath: scheduled ? execution.criticalPath : [],
+    criticalPathLength: scheduled ? execution.criticalPathLength : 0,
+    cycles: execution.cycles,
+    rows,
+    provenance: {
+      algorithm: "critical-path-method",
+      edgeFamily: "ordering",
+      weighting: "unit"
     }
-    if (state.terminal)
-      continue;
-    activeNodes += 1;
-    const degree = assembly.graph.incidentEdges(id).length;
-    if (degree > 1)
-      continue;
-    degreeLeqOneActive += 1;
-    if (degree === 0)
-      isolatedActiveNodes += 1;
-    if (exemptIsolates.has(id.toLowerCase()))
-      continue;
-    if (degree === 0)
-      isolates.push(id);
-    else
-      sparse.push(id);
+  };
+}
+
+// dist/sdk/graph/durable-cache.js
+import path from "node:path";
+var GRAPH_DURABLE_CACHE_VERSION = 1;
+var GRAPH_DURABLE_CACHE_MIN_ITEMS = 500;
+var MAX_DURABLE_RESULTS = 64;
+var DURABLE_GRAPH_CACHE_LOCK_ID = "graph-durable-cache";
+function acquireDurableGraphCacheLock(pmRoot) {
+  return acquireLock(pmRoot, DURABLE_GRAPH_CACHE_LOCK_ID, 30, `graph-cache:${process.pid}`, false, false, 3e3);
+}
+function durableGraphCachePath(pmRoot) {
+  return path.join(pmRoot, "runtime", "graph-cache.json");
+}
+function graphAuditBaselinePath(pmRoot) {
+  return path.join(pmRoot, "runtime", "graph-audit-baseline.json");
+}
+function decodeEnvelope(raw) {
+  if (raw === null)
+    return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || parsed.version !== GRAPH_DURABLE_CACHE_VERSION || typeof parsed.fingerprint !== "string" || typeof parsed.saved_at !== "string" || typeof parsed.results !== "object" || parsed.results === null || Array.isArray(parsed.results))
+      return void 0;
+    return parsed;
+  } catch {
+    return void 0;
   }
-  const findings = [];
-  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 \u2014 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.");
+}
+async function openDurableGraphCache(pmRoot, fingerprint) {
+  const raw = await readFileIfExists(durableGraphCachePath(pmRoot));
+  const envelope = decodeEnvelope(raw);
+  const fresh = envelope?.fingerprint === fingerprint;
   return {
-    findings,
-    profile: {
-      nodes: assembly.graph.nodes().length,
-      edges: assembly.graph.edges().length,
-      edges_by_kind: Object.fromEntries(Object.entries(edgesByKind).sort(([left], [right]) => left.localeCompare(right))),
-      active_nodes: activeNodes,
-      missing_nodes: missingNodes,
-      isolated_active_nodes: isolatedActiveNodes,
-      degree_leq_one_active_nodes: degreeLeqOneActive
-    }
+    exists: raw !== null,
+    fresh,
+    results: fresh ? envelope.results : {}
   };
 }
-function auditWorkspaceRelationshipGraph(assembly, options = {}) {
-  const isTerminal = options.isTerminal ?? ((status) => status === "closed" || status === "canceled");
-  const isBlocked = options.isBlocked ?? ((status) => status === "blocked");
-  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 nodeStates = new Map(assembly.details.map((detail) => [
-    detail.id,
-    {
-      id: detail.id,
-      status: detail.status,
-      missing: assembly.missingIdSet.has(detail.id.toLowerCase()),
-      terminal: isTerminal(detail.status)
-    }
-  ]));
-  options.signal?.throwIfAborted();
-  const edgesByKind = {};
-  for (const edge of assembly.graph.edges())
-    edgesByKind[edge.kind] = (edgesByKind[edge.kind] ?? 0) + 1;
-  const findings = collectIntegrityFindings(assembly, isTerminal, maxSampleSize);
-  options.signal?.throwIfAborted();
-  findings.push(...collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize));
-  options.signal?.throwIfAborted();
-  findings.push(...collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize));
-  options.signal?.throwIfAborted();
-  const coverage = collectCoverageReport(assembly, nodeStates, exemptIsolates, maxSampleSize, edgesByKind);
-  findings.push(...coverage.findings);
-  findings.sort((left, right) => SEVERITY_RANK[left.severity] - SEVERITY_RANK[right.severity] || left.code.localeCompare(right.code) || left.sample[0].localeCompare(right.sample[0]));
+async function persistDurableGraphResult(pmRoot, fingerprint, view, queryKey, result) {
+  const release = await acquireDurableGraphCacheLock(pmRoot);
+  try {
+    const envelope = decodeEnvelope(await readFileIfExists(durableGraphCachePath(pmRoot)));
+    const results = envelope?.fingerprint === fingerprint ? envelope.results : {};
+    delete results[queryKey];
+    results[queryKey] = result;
+    const keys = Object.keys(results);
+    for (const stale of keys.slice(0, Math.max(0, keys.length - MAX_DURABLE_RESULTS)))
+      delete results[stale];
+    await writeFileAtomic(durableGraphCachePath(pmRoot), JSON.stringify({
+      version: GRAPH_DURABLE_CACHE_VERSION,
+      fingerprint,
+      saved_at: (/* @__PURE__ */ new Date()).toISOString(),
+      results
+    }));
+    view.results = results;
+  } finally {
+    await release();
+  }
+}
+async function clearDurableGraphCache(pmRoot) {
+  const release = await acquireDurableGraphCacheLock(pmRoot);
+  try {
+    await removeFileIfExists(durableGraphCachePath(pmRoot));
+  } finally {
+    await release();
+  }
+}
+async function durableGraphCacheStatus(pmRoot, fingerprint) {
+  const cachePath = durableGraphCachePath(pmRoot);
+  const raw = await readFileIfExists(cachePath);
+  const envelope = decodeEnvelope(raw);
+  if (envelope === void 0)
+    return { exists: raw !== null, fresh: false, entry_count: 0 };
   return {
-    findings,
-    profile: coverage.profile
+    exists: true,
+    fresh: envelope.fingerprint === fingerprint,
+    entry_count: Object.keys(envelope.results).length,
+    fingerprint: envelope.fingerprint.slice(0, 12),
+    saved_at: envelope.saved_at,
+    bytes: Buffer.byteLength(raw, "utf8")
   };
 }
+function shouldPersistDurableGraphCache(itemCount, envelopeExists) {
+  return envelopeExists || itemCount >= GRAPH_DURABLE_CACHE_MIN_ITEMS;
+}
+function isNonnegativeCountRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((count) => Number.isInteger(count) && count >= 0);
+}
+function isNonnegativeCoverageByTypeRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  return Object.values(value).every((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry) && [entry.active, entry.isolated, entry.degree_leq_one].every((count) => Number.isInteger(count) && count >= 0));
+}
+function decodeBaseline(raw) {
+  if (raw === null)
+    return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null)
+      return void 0;
+    const snapshot = parsed;
+    const profile = snapshot.profile;
+    if (typeof snapshot.saved_at !== "string" || typeof snapshot.fingerprint !== "string" || !isNonnegativeCountRecord(snapshot.affected_subjects_by_code) || typeof profile !== "object" || profile === null || ![
+      profile.nodes,
+      profile.edges,
+      profile.active_nodes,
+      profile.missing_nodes,
+      profile.isolated_active_nodes,
+      profile.degree_leq_one_active_nodes
+    ].every((value) => Number.isInteger(value) && value >= 0) || !isNonnegativeCountRecord(profile.edges_by_kind) || profile.coverage_by_type !== void 0 && !isNonnegativeCoverageByTypeRecord(profile.coverage_by_type))
+      return void 0;
+    return {
+      ...snapshot,
+      profile: {
+        ...profile,
+        coverage_by_type: profile.coverage_by_type ?? {}
+      }
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function loadGraphAuditBaseline(pmRoot) {
+  return decodeBaseline(await readFileIfExists(graphAuditBaselinePath(pmRoot)));
+}
+async function saveGraphAuditBaseline(pmRoot, snapshot) {
+  await writeFileAtomic(graphAuditBaselinePath(pmRoot), JSON.stringify(snapshot));
+}
 
 // dist/sdk/graph/remediation.js
 var FINDING_STEP_TEMPLATES = {
@@ -1364,6 +1207,16 @@ var FINDING_STEP_TEMPLATES = {
     confidence: "high",
     rationale: "Duplicated spellings between terminal items are historical noise; waive or batch changelog-safe cleanup."
   },
+  duplicate_dependency_row: {
+    op: "remove",
+    confidence: "high",
+    rationale: "The identical dependency row is stored more than once on the holder; drop the repeats so the row exists exactly once \u2014 graph semantics are unchanged."
+  },
+  legacy_duplicate_dependency_row: {
+    op: "waive",
+    confidence: "high",
+    rationale: "Repeated identical rows on terminal holders are storage noise; waive or clean up only in a changelog-safe closed-item batch."
+  },
   stale_lifecycle_block: {
     op: "investigate",
     confidence: "medium",
@@ -1543,10 +1396,10 @@ function runGraphPaths(root, target, invocation) {
     count: result.value.length,
     ...projectQueryMeta(result.meta),
     ...invocation.summary ? {} : {
-      paths: result.value.map((path3) => ({
-        nodes: path3.nodes,
-        kinds: path3.edges.map((edge) => edge.kind),
-        length: path3.length
+      paths: result.value.map((path4) => ({
+        nodes: path4.nodes,
+        kinds: path4.edges.map((edge) => edge.kind),
+        length: path4.length
       }))
     }
   };
@@ -1611,7 +1464,8 @@ function runGraphAudit(invocation, isTerminal) {
   const report = auditWorkspaceRelationshipGraph(invocation.assembly, {
     isTerminal,
     ...invocation.sample === void 0 ? {} : { maxSampleSize: invocation.sample },
-    ...invocation.exemptIsolates.length === 0 ? {} : { exemptIsolates: invocation.exemptIsolates }
+    ...invocation.exemptIsolates.length === 0 ? {} : { exemptIsolates: invocation.exemptIsolates },
+    ...invocation.exemptIsolateTypes.length === 0 ? {} : { isolateExemptTypes: invocation.exemptIsolateTypes }
   });
   const bySeverity = {};
   const byCode = {};
@@ -1713,13 +1567,87 @@ function runGraphDominators(root, invocation) {
     }
   };
 }
+function runGraphSlack(invocation) {
+  const limit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
+  const analysis = analyzeRelationshipSchedule(invocation.assembly.graph);
+  const criticalCount = analysis.rows.filter((row) => row.critical).length;
+  return {
+    subcommand: "slack",
+    acyclic: analysis.acyclic,
+    makespan: analysis.makespan,
+    scheduled_count: analysis.scheduledCount,
+    critical_count: criticalCount,
+    critical_path_length: analysis.criticalPathLength,
+    cycle_count: analysis.cycles.length,
+    truncated: analysis.rows.length > limit,
+    ...invocation.summary ? {} : {
+      critical_path: analysis.criticalPath,
+      rows: analysis.rows.slice(0, limit).map((row) => ({
+        id: row.id,
+        earliest_start: row.earliestStart,
+        latest_start: row.latestStart,
+        slack: row.slack,
+        critical: row.critical
+      }))
+    }
+  };
+}
+function runGraphCentrality(invocation) {
+  const limit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
+  const result = computeRelationshipCentrality(invocation.assembly.graph, {
+    ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds }
+  });
+  const analysis = result.value;
+  return {
+    subcommand: "centrality",
+    node_count: analysis.nodeCount,
+    edge_count: analysis.edgeCount,
+    truncated: analysis.rows.length > limit,
+    cost: {
+      visited_nodes: result.meta.visitedNodes,
+      inspected_edges: result.meta.inspectedEdges
+    },
+    ...invocation.summary ? {} : {
+      rows: analysis.rows.slice(0, limit).map((row) => ({
+        id: row.id,
+        degree: row.degree,
+        in_degree: row.inDegree,
+        out_degree: row.outDegree,
+        betweenness: row.betweenness,
+        closeness: row.closeness
+      }))
+    }
+  };
+}
+function runGraphArticulation(invocation) {
+  const limit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
+  const result = findRelationshipCutStructure(invocation.assembly.graph, {
+    ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds }
+  });
+  const { articulationPoints, bridges } = result.value;
+  return {
+    subcommand: "articulation",
+    articulation_count: articulationPoints.length,
+    bridge_count: bridges.length,
+    truncated: articulationPoints.length > limit || bridges.length > limit,
+    cost: {
+      visited_nodes: result.meta.visitedNodes,
+      inspected_edges: result.meta.inspectedEdges
+    },
+    ...invocation.summary ? {} : {
+      articulation_points: articulationPoints.slice(0, limit),
+      bridges: bridges.slice(0, limit)
+    }
+  };
+}
 function runGraphPlan(invocation, isTerminal) {
   const limit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
   const plan = planRelationshipRemediation(invocation.assembly, {
     isTerminal,
     redundancyLimit: limit,
     ...invocation.sample === void 0 ? {} : { maxSampleSize: invocation.sample },
-    ...invocation.exemptIsolates.length === 0 ? {} : { exemptIsolates: invocation.exemptIsolates }
+    ...invocation.exemptIsolates.length === 0 ? {} : { exemptIsolates: invocation.exemptIsolates },
+    ...invocation.exemptIsolateTypes.length === 0 ? {} : { isolateExemptTypes: invocation.exemptIsolateTypes }
   });
   const byOp = {};
   const byCode = {};
@@ -1758,6 +1686,9 @@ function buildGraphQueryKey(subcommand, root, pathsTarget, invocation) {
     exemptIsolates: [
       ...new Set(invocation.exemptIsolates.map((id) => id.toLowerCase()))
     ].sort(),
+    exemptIsolateTypes: [
+      ...new Set(invocation.exemptIsolateTypes.map((type) => type.toLowerCase()))
+    ].sort(),
     summary: invocation.summary
   });
 }
@@ -1774,12 +1705,82 @@ function executeGraphSubcommand(subcommand, root, pathsTarget, invocation, isTer
     return runGraphRedundancy(invocation);
   if (subcommand === "dominators")
     return runGraphDominators(root, invocation);
+  if (subcommand === "slack")
+    return runGraphSlack(invocation);
+  if (subcommand === "centrality")
+    return runGraphCentrality(invocation);
+  if (subcommand === "articulation")
+    return runGraphArticulation(invocation);
   if (subcommand === "paths")
     return runGraphPaths(root, pathsTarget, invocation);
   if (subcommand === "impact")
     return runGraphImpact(root, invocation);
   return runGraphTraversal(subcommand, root, invocation);
 }
+function assertGraphFlagScope(subcommand, options) {
+  if (subcommand !== "index" && (options.rebuild === true || options.clear === true))
+    throw new PmCliError("--rebuild and --clear apply only to graph index.", EXIT_CODE.USAGE);
+  if (subcommand !== "audit" && options.saveBaseline === true)
+    throw new PmCliError("--save-baseline applies only to graph audit.", EXIT_CODE.USAGE);
+  if (subcommand === "slack" && options.kind !== void 0)
+    throw new PmCliError("graph slack analyzes every ordering kind; --kind is not supported.", EXIT_CODE.USAGE);
+  if (options.rebuild === true && options.clear === true)
+    throw new PmCliError("graph index accepts either --rebuild or --clear, not both.", EXIT_CODE.USAGE);
+}
+async function runGraphIndex(pmRoot, fingerprint, invocation, itemCount, isTerminal, options) {
+  let action = "status";
+  if (options.clear === true) {
+    await clearDurableGraphCache(pmRoot);
+    action = "cleared";
+  }
+  if (options.rebuild === true) {
+    await clearDurableGraphCache(pmRoot);
+    const view = await openDurableGraphCache(pmRoot, fingerprint);
+    const warmInvocation = {
+      assembly: invocation.assembly,
+      direction: "both",
+      exemptIsolates: [],
+      exemptIsolateTypes: [],
+      saveBaseline: false,
+      summary: true
+    };
+    for (const warm of ["analyze", "audit"]) {
+      await persistDurableGraphResult(pmRoot, fingerprint, view, buildGraphQueryKey(warm, void 0, void 0, warmInvocation), executeGraphSubcommand(warm, void 0, void 0, warmInvocation, isTerminal));
+    }
+    action = "rebuilt";
+  }
+  const status = await durableGraphCacheStatus(pmRoot, fingerprint);
+  return {
+    subcommand: "index",
+    action,
+    state: status.exists ? status.fresh ? "fresh" : "stale" : "absent",
+    entry_count: status.entry_count,
+    item_count: itemCount,
+    min_items_threshold: GRAPH_DURABLE_CACHE_MIN_ITEMS,
+    persist_enabled: shouldPersistDurableGraphCache(itemCount, status.exists),
+    current_fingerprint: fingerprint.slice(0, 12),
+    ...status.saved_at === void 0 ? {} : { saved_at: status.saved_at },
+    ...status.bytes === void 0 ? {} : { bytes: status.bytes }
+  };
+}
+async function applyAuditBaseline(pmRoot, fingerprint, audit, saveBaseline) {
+  const current = {
+    saved_at: (/* @__PURE__ */ new Date()).toISOString(),
+    fingerprint,
+    affected_subjects_by_code: audit.affected_subjects_by_code,
+    profile: audit.profile
+  };
+  const stored = await loadGraphAuditBaseline(pmRoot);
+  if (saveBaseline)
+    await saveGraphAuditBaseline(pmRoot, current);
+  return stored === void 0 ? audit : { ...audit, baseline: diffRelationshipAuditSnapshots(stored, current) };
+}
+async function persistDurableGraphResultBestEffort(pmRoot, fingerprint, view, queryKey, result) {
+  try {
+    await persistDurableGraphResult(pmRoot, fingerprint, view, queryKey, result);
+  } catch {
+  }
+}
 async function runGraph(subcommandRaw, id, target, options, global) {
   const subcommand = parseGraphSubcommand(subcommandRaw, id, target);
   const pmRoot = resolvePmRoot(process.cwd(), global.path);
@@ -1791,8 +1792,10 @@ async function runGraph(subcommandRaw, id, target, options, global) {
   const items = await listAllItemMetadataLight(pmRoot, settings.item_format, typeRegistry.type_to_folder, void 0, settings.schema);
   const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
   const isTerminal = (status) => isTerminalStatus(status, statusRegistry);
-  const kinds = parseKinds(options.kind);
-  const lookup = workspaceGraphCache().lookup(pmRoot, computeWorkspaceGraphFingerprint(items, isTerminal), () => assembleWorkspaceRelationshipGraph(items, isTerminal));
+  assertGraphFlagScope(subcommand, options);
+  const relationshipRegistry = resolveWorkspaceRelationshipKindRegistry();
+  const kinds = parseKinds(options.kind, relationshipRegistry);
+  const lookup = workspaceGraphCache().lookup(pmRoot, computeWorkspaceGraphFingerprint(items, isTerminal, relationshipRegistry), () => assembleWorkspaceRelationshipGraph(items, isTerminal, relationshipRegistry));
   const invocation = {
     assembly: lookup.assembly,
     ...kinds === void 0 ? {} : { kinds },
@@ -1803,17 +1806,31 @@ async function runGraph(subcommandRaw, id, target, options, global) {
     maxPaths: parsePositiveInteger(options.maxPaths, "max-paths"),
     sample: parsePositiveInteger(options.sample, "sample"),
     exemptIsolates: normalizeIdList(options.exemptIsolate),
+    exemptIsolateTypes: normalizeIdList(options.exemptIsolateType),
+    saveBaseline: options.saveBaseline === true,
     summary: options.summary === true
   };
+  if (subcommand === "index") {
+    return runGraphIndex(pmRoot, lookup.fingerprint, invocation, items.length, isTerminal, options);
+  }
   const root = ROOTED_SUBCOMMANDS.has(subcommand) ? canonicalizeGraphId(invocation.assembly, id) : void 0;
   const pathsTarget = subcommand === "paths" ? canonicalizeGraphId(invocation.assembly, target) : void 0;
-  const memo = lookup.memoize(buildGraphQueryKey(subcommand, root, pathsTarget, invocation), () => executeGraphSubcommand(subcommand, root, pathsTarget, invocation, isTerminal));
+  const queryKey = buildGraphQueryKey(subcommand, root, pathsTarget, invocation);
+  const durableView = await openDurableGraphCache(pmRoot, lookup.fingerprint);
+  const durableValue = durableView.results[queryKey];
+  const memo = lookup.memoize(queryKey, () => durableValue !== void 0 ? structuredClone(durableValue) : executeGraphSubcommand(subcommand, root, pathsTarget, invocation, isTerminal));
+  const persistEnabled = shouldPersistDurableGraphCache(items.length, durableView.exists);
+  if (!memo.reused && durableValue === void 0 && persistEnabled) {
+    await persistDurableGraphResultBestEffort(pmRoot, lookup.fingerprint, durableView, queryKey, memo.value);
+  }
+  const value = memo.value.subcommand === "audit" ? await applyAuditBaseline(pmRoot, lookup.fingerprint, memo.value, invocation.saveBaseline) : memo.value;
   return {
-    ...memo.value,
+    ...value,
     cache: {
       fingerprint: lookup.fingerprint.slice(0, 12),
       assembly: lookup.assemblyReused ? "hit" : "miss",
-      result: memo.reused ? "hit" : "miss"
+      result: memo.reused ? "hit" : "miss",
+      durable: durableValue !== void 0 ? "hit" : persistEnabled ? "miss" : "off"
     }
   };
 }
@@ -2207,7 +2224,7 @@ async function runGet(id, global, options = {}) {
 
 // dist/sdk/query/search.js
 import fs from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 
 // dist/core/shared/text-normalization.js
 function normalizeLowercaseWhitespace(value) {
@@ -3109,7 +3126,7 @@ function collectLinkedPaths(item) {
   return [...deduped.values()];
 }
 async function resolveContainmentRoot(root) {
-  const resolved = path.resolve(root);
+  const resolved = path2.resolve(root);
   try {
     const realpathRoot = await fs.realpath(resolved);
     return {
@@ -3138,7 +3155,7 @@ async function loadLinkedCorpus(document, roots) {
     if (!containmentRoot) {
       continue;
     }
-    const resolved = path.resolve(containmentRoot.resolved, linkedPath.path);
+    const resolved = path2.resolve(containmentRoot.resolved, linkedPath.path);
     if (!isPathWithinDirectory(containmentRoot.resolved, resolved)) {
       continue;
     }
@@ -3960,7 +3977,7 @@ async function loadDocuments(pmRoot, itemFormat, typeToFolder, schema) {
       try {
         return await tryRead(alternatePath, alternateFormat);
       } catch {
-        listWarnings.push(`item_list_item_read_failed:${path.relative(pmRoot, alternatePath)}`);
+        listWarnings.push(`item_list_item_read_failed:${path2.relative(pmRoot, alternatePath)}`);
         return "";
       }
     }
@@ -4465,7 +4482,7 @@ async function runSearch(rawQuery, rawOptions, global) {
 
 // dist/sdk/eval.js
 import fs2 from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // dist/core/search/eval.js
 var DEFAULT_EVAL_K = 10;
@@ -4604,7 +4621,7 @@ function parseEvalQuerySet(raw) {
 }
 
 // dist/sdk/eval.js
-var DEFAULT_EVAL_QUERIES_RELATIVE_PATH = path2.join("search", "eval-queries.json");
+var DEFAULT_EVAL_QUERIES_RELATIVE_PATH = path3.join("search", "eval-queries.json");
 var VALID_EVAL_MODES2 = /* @__PURE__ */ new Set([
   "keyword",
   "semantic",
@@ -4685,7 +4702,7 @@ var validateEvalQuerySet = (parsed) => {
   }
 };
 var loadEvalQuerySet = async (queriesPath) => validateEvalQuerySet(parseEvalQuerySetJson(await readEvalQuerySetFile(queriesPath), queriesPath));
-var resolveEvalQueriesPath = (pmRoot, queries) => queries ? path2.resolve(process.cwd(), queries) : path2.join(pmRoot, DEFAULT_EVAL_QUERIES_RELATIVE_PATH);
+var resolveEvalQueriesPath = (pmRoot, queries) => queries ? path3.resolve(process.cwd(), queries) : path3.join(pmRoot, DEFAULT_EVAL_QUERIES_RELATIVE_PATH);
 var evaluateEvalQuery = async (evalQuery, defaultMode, k, global) => {
   const mode = evalQuery.mode ?? defaultMode;
   const searchResult = await runSearch(evalQuery.query, { mode, limit: String(k), fields: "id" }, global);
@@ -4743,17 +4760,24 @@ var runEval = async (options, global) => {
 
 export {
   runAggregate,
-  hierarchyAncestors,
-  hierarchyDescendants,
-  orderingPredecessors,
-  orderingSuccessors,
-  enumerateRelationshipPaths,
-  detectRelationshipCommunities,
-  findRedundantRelationshipEdges,
-  computeRelationshipDominators,
-  formatDuplicateEdgeGroup,
-  collectDuplicateRelationshipEdgeGroups,
-  auditWorkspaceRelationshipGraph,
+  analyzeRelationshipExecution,
+  analyzeGraphImpact,
+  analyzeKnowledgeGraph,
+  compareRelationshipSnapshots,
+  computeRelationshipCentrality,
+  findRelationshipCutStructure,
+  analyzeRelationshipSchedule,
+  GRAPH_DURABLE_CACHE_VERSION,
+  GRAPH_DURABLE_CACHE_MIN_ITEMS,
+  durableGraphCachePath,
+  graphAuditBaselinePath,
+  openDurableGraphCache,
+  persistDurableGraphResult,
+  clearDurableGraphCache,
+  durableGraphCacheStatus,
+  shouldPersistDurableGraphCache,
+  loadGraphAuditBaseline,
+  saveGraphAuditBaseline,
   planRelationshipRemediation,
   parseGraphSubcommand,
   runGraph,
@@ -4767,6 +4791,6 @@ export {
   DEFAULT_EVAL_QUERIES_RELATIVE_PATH,
   runEval
 };
-//# sourceMappingURL=chunk-NHT3F4WZ.js.map
+//# sourceMappingURL=chunk-NUF7ROFH.js.map
 
-//# debugId=4c8b3841-40b8-5707-9154-ff020ed23bfd
+//# debugId=405abecd-c7c4-543d-be2a-eb3e5168def7