@unbrained/pm-cli 2026.7.17 → 2026.7.18

package/dist/cli-bundle/chunks/{chunk-6XAZB6SE.js → chunk-QPGQNLPI.js}

@@ -1,8 +1,20 @@
 
-!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]="d283a9b1-313e-53dc-a34a-1b8b0c2cb0ac")}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]="2289448d-a087-55eb-a092-70c2f25227d6")}catch(e){}}();
+import {
+  computeWorkspaceGraphFingerprint,
+  parseDirection,
+  parseKinds,
+  parseMaxDepth,
+  parsePositiveInteger,
+  workspaceGraphCache
+} from "./chunk-EX7OQT3Y.js";
 import {
   collectStaleVectorizationIds
-} from "./chunk-SPFZV2GR.js";
+} from "./chunk-XPUTSGJU.js";
+import {
+  assembleWorkspaceRelationshipGraph,
+  createRelationshipKindRegistry
+} from "./chunk-L5BTTDU5.js";
 import {
   buildListQueryFilters
 } from "./chunk-N7V7TI6J.js";
@@ -21,7 +33,7 @@ import {
   resolveContentFieldFilters,
   resolveMissingMetadataFilters,
   runList
-} from "./chunk-SIJV365F.js";
+} from "./chunk-NCVT6XEL.js";
 import {
   createQueryFingerprint,
   paginateQueryRows
@@ -59,7 +71,10 @@ import {
   resolveSearchCorpusFields,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-AFSV5HBB.js";
+} from "./chunk-E4FXM2XB.js";
+import {
+  GRAPH_SUBCOMMAND_VALUES
+} from "./chunk-7UCY6DR5.js";
 import {
   splitCommaList
 } from "./chunk-NETP4DY4.js";
@@ -3369,6 +3384,1626 @@ async function runGet(id, global, options = {}) {
   return result;
 }
 
+// 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 (visited.has(current.id))
+      continue;
+    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 });
+  }
+}
+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);
+      }
+    }
+    components.push(component);
+  }
+  return sortComponents(components);
+}
+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 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 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 layers;
+}
+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 path3 = end === void 0 ? [] : [end];
+  while (path3[0] !== void 0 && parent.has(path3[0]))
+    path3.unshift(parent.get(path3[0]));
+  return { depth: Object.fromEntries(depth), path: path3 };
+}
+function reconstructImpactPath(root, target, parents) {
+  const path3 = [target];
+  let cursor = target;
+  while (cursor !== root) {
+    cursor = parents.get(cursor);
+    path3.push(cursor);
+  }
+  return path3.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;
+  traversal: for (let index = 0; index < queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    const current = queue[index];
+    visitedNodes += 1;
+    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;
+    }
+    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 {
+    root,
+    affected,
+    exact: true,
+    truncated,
+    cost: { visitedNodes, inspectedEdges }
+  };
+}
+function analyzeKnowledgeGraph(graph) {
+  const nodes = [...graph.nodes()];
+  const weak = createAdjacency(nodes);
+  const directed = createAdjacency(nodes);
+  for (const edge of graph.edges()) {
+    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;
+    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 {
+    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 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
+  };
+}
+
+// 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))
+      continue;
+    if (seen.has(row.id))
+      continue;
+    seen.add(row.id);
+    neighbors.push(row.id);
+  }
+  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;
+      continue;
+    }
+    if (state.value.length >= limit) {
+      state.truncated = true;
+      return true;
+    }
+    state.value.push(neighbor);
+  }
+  return false;
+}
+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 assertPathEndpoint(graph, id) {
+  if (!graph.hasNode(id))
+    throw new TypeError(`Relationship node not found: ${id}`);
+}
+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 });
+    }
+  }
+  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);
+}
+function enumerateNonZeroRelationshipPaths(graph, source, target, options, maxPaths, maxVisitedPaths, maxDepth, direction) {
+  const state = {
+    value: [],
+    queue: [{ nodes: [source], nodeSet: /* @__PURE__ */ new Set([source]), edges: [] }],
+    inspectedEdges: 0
+  };
+  let visitedNodes = 0;
+  let truncated = false;
+  const probeLimit = maxPaths + 1;
+  for (let index = 0; index < state.queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    if (state.value.length >= probeLimit || visitedNodes >= maxVisitedPaths) {
+      truncated = true;
+      break;
+    }
+    const partial = state.queue[index];
+    visitedNodes += 1;
+    if (partial.edges.length >= maxDepth) {
+      if (readPathContinuations(graph, partial, options, direction, state).length > 0)
+        truncated = true;
+      continue;
+    }
+    if (expandPartialPath(graph, partial, target, options, direction, probeLimit, state)) {
+      truncated = true;
+      break;
+    }
+  }
+  return {
+    value: state.value.slice(0, maxPaths),
+    meta: { visitedNodes, inspectedEdges: state.inspectedEdges, truncated }
+  };
+}
+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();
+  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)
+      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;
+      }
+    }
+  }
+  return {
+    value: {
+      communities: collectCommunities(labels, minSize),
+      iterations,
+      converged
+    },
+    meta: { visitedNodes, inspectedEdges, truncated: !converged }
+  };
+}
+function isTransitiveKind(definition) {
+  return definition.direction === "directed" && (definition.ordering || definition.hierarchy);
+}
+function transitiveFamilyKey(definition) {
+  return definition.inverse !== void 0 && definition.inverse < definition.kind ? definition.inverse : definition.kind;
+}
+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 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));
+  }
+  return families;
+}
+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);
+    }
+    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 });
+  }
+  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 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 = [];
+  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 });
+    }
+  }
+  return {
+    value,
+    meta: {
+      visitedNodes: cost.visitedNodes,
+      inspectedEdges: cost.inspectedEdges,
+      truncated
+    }
+  };
+}
+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 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));
+  }
+  return {
+    order,
+    successors,
+    predecessors: state.predecessors,
+    inspectedEdges,
+    truncated: state.truncated
+  };
+}
+function reversePostorder(subgraph, root) {
+  const postorder = [];
+  const visited = /* @__PURE__ */ new Set([root]);
+  const stack = [{ id: root, index: 0 }];
+  while (stack.length > 0) {
+    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 });
+      }
+    } else {
+      postorder.push(frame.id);
+      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)
+      continue;
+    const parent = idom.get(id);
+    subtreeSizes.set(parent, subtreeSizes.get(parent) + subtreeSizes.get(id));
+  }
+  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 },
+    meta: {
+      visitedNodes: subgraph.order.length,
+      inspectedEdges: subgraph.inspectedEdges,
+      truncated: subgraph.truncated
+    }
+  };
+}
+
+// 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()) {
+    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);
+    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)));
+  }
+  return true;
+}
+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;
+  }
+  if (component.length > 1 || component.length === 1 && successors.get(component[0])?.includes(component[0]))
+    state.components.push(component.sort((left, right) => left.localeCompare(right)));
+}
+function collectOrderingCycles(successors) {
+  const state = {
+    indexes: /* @__PURE__ */ new Map(),
+    lowLinks: /* @__PURE__ */ new Map(),
+    onStack: /* @__PURE__ */ new Set(),
+    stack: [],
+    components: [],
+    nextIndex: 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 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;
+    }
+    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);
+  }
+  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.");
+  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
+    }
+  };
+}
+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]));
+  return {
+    findings,
+    profile: coverage.profile
+  };
+}
+
+// dist/sdk/graph/remediation.js
+var FINDING_STEP_TEMPLATES = {
+  missing_reference_active: {
+    op: "investigate",
+    confidence: "medium",
+    rationale: "Restore or re-create the referenced item, or remove/retype the reference on the active holder; the correct fix depends on why the target is absent."
+  },
+  missing_reference_terminal: {
+    op: "waive",
+    confidence: "high",
+    rationale: "Terminal-holder reference to an absent item is historical debt; waive it or clean it up only in a dedicated changelog-safe closed-item batch."
+  },
+  legacy_no_blocker_sentinel: {
+    op: "remove",
+    confidence: "high",
+    rationale: "The pre-structured-dependency no-active-blocker sentinel is retired and carries no information; blocker state derives from blocked_by edges."
+  },
+  ordering_cycle: {
+    op: "investigate",
+    confidence: "low",
+    rationale: "Every cycle member is unschedulable until one ordering edge is removed or retyped; the planner never chooses which edge to cut."
+  },
+  legacy_ordering_cycle: {
+    op: "waive",
+    confidence: "high",
+    rationale: "Terminal-only ordering cycles have no scheduling effect; repairing them would mutate closed history (changelog drag)."
+  },
+  // duplicate_edge findings are expanded into per-stored-edge remove steps by
+  // the planner itself (see stepsFromDuplicateGroup); this template documents
+  // the family for exhaustiveness and backs any future sample-only fallback.
+  duplicate_edge: {
+    op: "remove",
+    confidence: "high",
+    rationale: "Parallel same-family spellings state one relationship twice; remove all but one stored spelling, keeping the holder's canonical direction."
+  },
+  legacy_duplicate_edge: {
+    op: "waive",
+    confidence: "high",
+    rationale: "Duplicated spellings between terminal items are historical noise; waive or batch changelog-safe cleanup."
+  },
+  stale_lifecycle_block: {
+    op: "investigate",
+    confidence: "medium",
+    rationale: "Re-open the missing prerequisite as an ordering edge, or move the item back to an active status; only the holder's owner knows which is true."
+  },
+  isolated_active_node: {
+    op: "investigate",
+    confidence: "medium",
+    rationale: "Link the item to its parent, prerequisite, or origin \u2014 or register it as an explicitly exempt isolate; the audit never fabricates an edge."
+  },
+  sparse_active_node: {
+    op: "investigate",
+    confidence: "low",
+    rationale: "Investigate for an honest second edge (story-to-task, defect family, cross-epic complement); sparse is not automatically defective."
+  }
+};
+function formatStoredEdge(edge) {
+  return `${edge.source} -${edge.kind}-> ${edge.target}`;
+}
+function stepsFromDuplicateGroup(group) {
+  const [keeper, ...extras] = group.edges;
+  return extras.map((edge) => ({
+    op: "remove",
+    code: "duplicate_edge",
+    subject: formatStoredEdge(edge),
+    rationale: "This stored spelling restates the kept canonical edge of the same semantic family; removing it leaves the relationship stated exactly once.",
+    evidence: [
+      `keep: ${formatStoredEdge(keeper)}`,
+      `group: ${formatDuplicateEdgeGroup(group)}`
+    ],
+    confidence: "high"
+  }));
+}
+function stepsFromFinding(finding, duplicateGroups) {
+  if (finding.code === "duplicate_edge") {
+    return finding.sample.flatMap((subject) => stepsFromDuplicateGroup(duplicateGroups.get(subject)));
+  }
+  const template = FINDING_STEP_TEMPLATES[finding.code];
+  return finding.sample.map((subject) => ({
+    op: template.op,
+    code: finding.code,
+    subject,
+    rationale: template.rationale,
+    evidence: [finding.policy],
+    confidence: template.confidence
+  }));
+}
+function planRelationshipRemediation(assembly, options = {}) {
+  const { redundancyLimit, ...auditOptions } = options;
+  const report = auditWorkspaceRelationshipGraph(assembly, auditOptions);
+  const duplicateGroups = new Map(collectDuplicateRelationshipEdgeGroups(assembly).map((group) => [
+    formatDuplicateEdgeGroup(group),
+    group
+  ]));
+  const steps = report.findings.flatMap((finding) => stepsFromFinding(finding, duplicateGroups));
+  let truncated = report.findings.some((finding) => finding.sample_truncated);
+  options.signal?.throwIfAborted();
+  const redundancy = findRedundantRelationshipEdges(assembly.graph, {
+    limit: redundancyLimit ?? options.maxSampleSize ?? 25,
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  });
+  for (const row of redundancy.value) {
+    steps.push({
+      op: "remove",
+      code: "redundant_edge",
+      subject: `${row.edge.source} -> ${row.edge.target} (${row.edge.kind})`,
+      rationale: "The stored edge is implied by a longer same-family witness path; shortcut edges are sometimes deliberate emphasis, so confirm intent before removing.",
+      evidence: [`witness: ${row.witness.join(" -> ")}`],
+      confidence: "medium"
+    });
+  }
+  truncated = truncated || redundancy.meta.truncated;
+  return {
+    steps,
+    report,
+    truncated,
+    cost: {
+      visitedNodes: redundancy.meta.visitedNodes,
+      inspectedEdges: redundancy.meta.inspectedEdges
+    }
+  };
+}
+
+// dist/sdk/graph/run.js
+var ROOTED_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "ancestors",
+  "descendants",
+  "predecessors",
+  "successors",
+  "paths",
+  "impact",
+  "dominators"
+]);
+var DEFAULT_SAMPLE_LIMIT = 10;
+function normalizeIdList(raw) {
+  if (raw === void 0)
+    return [];
+  return (Array.isArray(raw) ? raw : [raw]).flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function parseGraphSubcommand(raw, id, target) {
+  const candidate = raw.trim().toLowerCase();
+  if (!GRAPH_SUBCOMMAND_VALUES.includes(candidate)) {
+    throw new PmCliError(`Invalid graph subcommand "${raw}". Use one of: ${GRAPH_SUBCOMMAND_VALUES.join(", ")}.`, EXIT_CODE.USAGE);
+  }
+  const subcommand = candidate;
+  if (ROOTED_SUBCOMMANDS.has(subcommand) && !id?.trim()) {
+    throw new PmCliError(`graph ${subcommand} requires an item id.`, EXIT_CODE.USAGE);
+  }
+  if (subcommand === "paths" && !target?.trim()) {
+    throw new PmCliError("graph paths requires a source and a target item id.", EXIT_CODE.USAGE);
+  }
+  return subcommand;
+}
+function rethrowGraphUsage(error) {
+  if (error instanceof TypeError)
+    throw new PmCliError(error.message, EXIT_CODE.USAGE);
+  throw error;
+}
+function projectQueryMeta(meta) {
+  return {
+    truncated: meta.truncated,
+    cost: {
+      visited_nodes: meta.visitedNodes,
+      inspected_edges: meta.inspectedEdges
+    }
+  };
+}
+function canonicalizeGraphId(assembly, raw) {
+  const wanted = raw.trim().toLowerCase();
+  for (const detail of assembly.details) {
+    if (detail.id.trim().toLowerCase() === wanted && !assembly.missingIdSet.has(detail.id.toLowerCase())) {
+      return detail.id;
+    }
+  }
+  throw new PmCliError(`Item ${raw} not found`, EXIT_CODE.NOT_FOUND);
+}
+function runGraphTraversal(subcommand, root, invocation) {
+  const walk = {
+    ancestors: hierarchyAncestors,
+    descendants: hierarchyDescendants,
+    predecessors: orderingPredecessors,
+    successors: orderingSuccessors
+  }[subcommand];
+  let result;
+  try {
+    result = walk(invocation.assembly.graph, root, {
+      ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds },
+      ...invocation.maxDepth === void 0 ? {} : { maxDepth: invocation.maxDepth },
+      ...invocation.limit === void 0 ? {} : { limit: invocation.limit },
+      ...invocation.after === void 0 ? {} : { after: invocation.after }
+    });
+  } catch (error) {
+    rethrowGraphUsage(error);
+  }
+  const meta = projectQueryMeta(result.meta);
+  return {
+    subcommand,
+    root,
+    count: result.value.length,
+    ...meta,
+    ...result.meta.nextCursor === void 0 ? {} : { next_cursor: result.meta.nextCursor },
+    ...invocation.summary ? {} : { ids: result.value }
+  };
+}
+function runGraphPaths(root, target, invocation) {
+  const result = enumerateRelationshipPaths(invocation.assembly.graph, root, target, {
+    direction: invocation.direction,
+    ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds },
+    ...invocation.maxDepth === void 0 ? {} : { maxDepth: invocation.maxDepth },
+    ...invocation.maxPaths === void 0 ? {} : { maxPaths: invocation.maxPaths }
+  });
+  return {
+    subcommand: "paths",
+    root,
+    target,
+    direction: invocation.direction,
+    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
+      }))
+    }
+  };
+}
+function runGraphImpact(root, invocation) {
+  const analysis = analyzeGraphImpact(invocation.assembly.graph, root, {
+    direction: invocation.direction,
+    ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds },
+    ...invocation.maxDepth === void 0 ? {} : { maxDepth: invocation.maxDepth },
+    ...invocation.limit === void 0 ? {} : { limit: invocation.limit }
+  });
+  return {
+    subcommand: "impact",
+    root,
+    direction: invocation.direction,
+    count: analysis.affected.length,
+    truncated: analysis.truncated,
+    cost: {
+      visited_nodes: analysis.cost.visitedNodes,
+      inspected_edges: analysis.cost.inspectedEdges
+    },
+    ...invocation.summary ? {} : { affected: analysis.affected }
+  };
+}
+function runGraphAnalyze(invocation) {
+  const graph = invocation.assembly.graph;
+  const sampleLimit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
+  const execution = analyzeRelationshipExecution(graph, {
+    registry: graph.registry()
+  });
+  const knowledge = analyzeKnowledgeGraph(graph);
+  return {
+    subcommand: "analyze",
+    node_count: graph.nodes().length,
+    edge_count: graph.edges().length,
+    sample_limit: sampleLimit,
+    execution: {
+      acyclic: execution.acyclic,
+      ordered_node_count: execution.order.length,
+      layer_count: execution.layers.length,
+      frontier_count: execution.frontier.length,
+      critical_path_length: execution.criticalPathLength,
+      cycle_count: execution.cycles.length,
+      ...invocation.summary ? {} : {
+        frontier: execution.frontier.slice(0, sampleLimit),
+        critical_path: execution.criticalPath.slice(0, sampleLimit),
+        cycles: execution.cycles.slice(0, sampleLimit)
+      }
+    },
+    knowledge: {
+      component_count: knowledge.components.length,
+      largest_component_size: knowledge.components[0]?.length ?? 0,
+      orphan_count: knowledge.orphans.length,
+      ...invocation.summary ? {} : {
+        orphans: knowledge.orphans.slice(0, sampleLimit),
+        hubs: knowledge.hubs.slice(0, sampleLimit)
+      }
+    }
+  };
+}
+function runGraphAudit(invocation, isTerminal) {
+  const report = auditWorkspaceRelationshipGraph(invocation.assembly, {
+    isTerminal,
+    ...invocation.sample === void 0 ? {} : { maxSampleSize: invocation.sample },
+    ...invocation.exemptIsolates.length === 0 ? {} : { exemptIsolates: invocation.exemptIsolates }
+  });
+  const bySeverity = {};
+  const byCode = {};
+  for (const finding of report.findings) {
+    bySeverity[finding.severity] = (bySeverity[finding.severity] ?? 0) + 1;
+    byCode[finding.code] = (byCode[finding.code] ?? 0) + finding.count;
+  }
+  return {
+    subcommand: "audit",
+    finding_count: report.findings.length,
+    findings_by_severity: bySeverity,
+    findings_by_code: byCode,
+    profile: report.profile,
+    ...invocation.summary ? {} : { findings: report.findings }
+  };
+}
+function runGraphCommunities(invocation) {
+  const sampleLimit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
+  const result = detectRelationshipCommunities(invocation.assembly.graph, {
+    ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds }
+  });
+  const analysis = result.value;
+  return {
+    subcommand: "communities",
+    community_count: analysis.communities.length,
+    largest_community_size: analysis.communities[0]?.size ?? 0,
+    iterations: analysis.iterations,
+    converged: analysis.converged,
+    truncated: !analysis.converged || analysis.communities.length > sampleLimit,
+    cost: {
+      visited_nodes: result.meta.visitedNodes,
+      inspected_edges: result.meta.inspectedEdges
+    },
+    ...invocation.summary ? {} : {
+      communities: analysis.communities.slice(0, sampleLimit).map((community) => ({
+        representative: community.representative,
+        size: community.size,
+        members: community.members.slice(0, sampleLimit)
+      }))
+    }
+  };
+}
+function runGraphRedundancy(invocation) {
+  let result;
+  try {
+    result = findRedundantRelationshipEdges(invocation.assembly.graph, {
+      ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds },
+      ...invocation.maxDepth === void 0 ? {} : { maxDepth: invocation.maxDepth },
+      ...invocation.limit === void 0 ? {} : { limit: invocation.limit }
+    });
+  } catch (error) {
+    rethrowGraphUsage(error);
+  }
+  return {
+    subcommand: "redundancy",
+    redundant_count: result.value.length,
+    ...projectQueryMeta(result.meta),
+    ...invocation.summary ? {} : {
+      redundant: result.value.map((row) => ({
+        source: row.edge.source,
+        target: row.edge.target,
+        kind: row.edge.kind,
+        witness: row.witness
+      }))
+    }
+  };
+}
+function runGraphDominators(root, invocation) {
+  const limit = invocation.limit ?? DEFAULT_SAMPLE_LIMIT;
+  const result = computeRelationshipDominators(invocation.assembly.graph, root, {
+    direction: invocation.direction,
+    ...invocation.kinds === void 0 ? {} : { kinds: invocation.kinds },
+    ...invocation.maxDepth === void 0 ? {} : { maxDepth: invocation.maxDepth }
+  });
+  const bottlenecks = result.value.rows.filter((row) => row.dominatedCount > 0);
+  return {
+    subcommand: "dominators",
+    root,
+    direction: invocation.direction,
+    reachable_count: result.value.reachableCount,
+    bottleneck_count: bottlenecks.length,
+    truncated: result.meta.truncated || bottlenecks.length > limit,
+    cost: {
+      visited_nodes: result.meta.visitedNodes,
+      inspected_edges: result.meta.inspectedEdges
+    },
+    ...invocation.summary ? {} : {
+      bottlenecks: bottlenecks.slice(0, limit).map((row) => ({
+        id: row.id,
+        idom: row.idom,
+        dominated_count: row.dominatedCount
+      }))
+    }
+  };
+}
+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 }
+  });
+  const byOp = {};
+  const byCode = {};
+  for (const step of plan.steps) {
+    byOp[step.op] = (byOp[step.op] ?? 0) + 1;
+    byCode[step.code] = (byCode[step.code] ?? 0) + 1;
+  }
+  return {
+    subcommand: "plan",
+    step_count: plan.steps.length,
+    steps_by_op: byOp,
+    steps_by_code: byCode,
+    finding_count: plan.report.findings.length,
+    truncated: plan.truncated || plan.steps.length > limit,
+    cost: {
+      visited_nodes: plan.cost.visitedNodes,
+      inspected_edges: plan.cost.inspectedEdges
+    },
+    ...invocation.summary ? {} : { steps: plan.steps.slice(0, limit) }
+  };
+}
+function buildGraphQueryKey(subcommand, root, pathsTarget, invocation) {
+  return JSON.stringify({
+    subcommand,
+    root: root ?? null,
+    target: pathsTarget ?? null,
+    kinds: invocation.kinds ?? null,
+    maxDepth: invocation.maxDepth ?? null,
+    limit: invocation.limit ?? null,
+    after: invocation.after ?? null,
+    direction: invocation.direction,
+    maxPaths: invocation.maxPaths ?? null,
+    sample: invocation.sample ?? null,
+    // The audit consumes exemptions as a case-insensitive set, so the key
+    // must not distinguish logically identical spellings or orderings.
+    exemptIsolates: [
+      ...new Set(invocation.exemptIsolates.map((id) => id.toLowerCase()))
+    ].sort(),
+    summary: invocation.summary
+  });
+}
+function executeGraphSubcommand(subcommand, root, pathsTarget, invocation, isTerminal) {
+  if (subcommand === "analyze")
+    return runGraphAnalyze(invocation);
+  if (subcommand === "audit")
+    return runGraphAudit(invocation, isTerminal);
+  if (subcommand === "plan")
+    return runGraphPlan(invocation, isTerminal);
+  if (subcommand === "communities")
+    return runGraphCommunities(invocation);
+  if (subcommand === "redundancy")
+    return runGraphRedundancy(invocation);
+  if (subcommand === "dominators")
+    return runGraphDominators(root, invocation);
+  if (subcommand === "paths")
+    return runGraphPaths(root, pathsTarget, invocation);
+  if (subcommand === "impact")
+    return runGraphImpact(root, invocation);
+  return runGraphTraversal(subcommand, root, invocation);
+}
+async function runGraph(subcommandRaw, id, target, options, global) {
+  const subcommand = parseGraphSubcommand(subcommandRaw, id, target);
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  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));
+  const invocation = {
+    assembly: lookup.assembly,
+    ...kinds === void 0 ? {} : { kinds },
+    maxDepth: parseMaxDepth(options.maxDepth),
+    limit: parsePositiveInteger(options.limit, "limit"),
+    after: options.after?.trim() || void 0,
+    direction: parseDirection(options.direction),
+    maxPaths: parsePositiveInteger(options.maxPaths, "max-paths"),
+    sample: parsePositiveInteger(options.sample, "sample"),
+    exemptIsolates: normalizeIdList(options.exemptIsolate),
+    summary: options.summary === true
+  };
+  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));
+  return {
+    ...memo.value,
+    cache: {
+      fingerprint: lookup.fingerprint.slice(0, 12),
+      assembly: lookup.assemblyReused ? "hit" : "miss",
+      result: memo.reused ? "hit" : "miss"
+    }
+  };
+}
+
 export {
   runAggregate,
   runSearch,
@@ -3379,8 +5014,26 @@ export {
   buildItemChildrenRollup,
   itemHasSchedule,
   buildItemSchedule,
-  runGet
+  runGet,
+  analyzeRelationshipExecution,
+  analyzeGraphImpact,
+  analyzeKnowledgeGraph,
+  compareRelationshipSnapshots,
+  hierarchyAncestors,
+  hierarchyDescendants,
+  orderingPredecessors,
+  orderingSuccessors,
+  enumerateRelationshipPaths,
+  detectRelationshipCommunities,
+  findRedundantRelationshipEdges,
+  computeRelationshipDominators,
+  formatDuplicateEdgeGroup,
+  collectDuplicateRelationshipEdgeGroups,
+  auditWorkspaceRelationshipGraph,
+  planRelationshipRemediation,
+  parseGraphSubcommand,
+  runGraph
 };
-//# sourceMappingURL=chunk-6XAZB6SE.js.map
+//# sourceMappingURL=chunk-QPGQNLPI.js.map
 
-//# debugId=d283a9b1-313e-53dc-a34a-1b8b0c2cb0ac
+//# debugId=2289448d-a087-55eb-a092-70c2f25227d6