@unbrained/pm-cli 2026.7.14 → 2026.7.16

package/dist/cli-bundle/chunks/chunk-BKVG6XOA.js

@@ -0,0 +1,1114 @@
+import {
+  createQueryFingerprint,
+  encodeQueryCursor,
+  resolveQueryCursorStart
+} from "./chunk-4223PVZT.js";
+import {
+  getActiveExtensionRegistrations,
+  isTerminalStatus,
+  listAllItemMetadataLight,
+  readSettings
+} from "./chunk-XSJUSQAE.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  getSettingsPath,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeStatusRegistry
+} from "./chunk-BSEQUTQP.js";
+
+// dist/sdk/relationships.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f5e9e0a6-4550-5e55-9fef-ee54ec06a495");
+  } catch (e2) {
+  }
+})();
+var BUILTIN_RELATIONSHIP_KINDS = [
+  {
+    kind: "blocked_by",
+    direction: "directed",
+    inverse: "blocks",
+    ordering: true,
+    precedence: "target_before_source",
+    hierarchy: false,
+    outgoing: "many",
+    incoming: "many",
+    lifecycle: "persistent",
+    aliases: ["depends_on"],
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "blocks",
+    direction: "directed",
+    inverse: "blocked_by",
+    ordering: true,
+    precedence: "source_before_target",
+    hierarchy: false,
+    outgoing: "many",
+    incoming: "many",
+    lifecycle: "persistent",
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "parent",
+    direction: "directed",
+    inverse: "child",
+    ordering: false,
+    hierarchy: true,
+    hierarchyDirection: "target_parent",
+    outgoing: "one",
+    incoming: "many",
+    lifecycle: "supersedable",
+    aliases: ["child_of", "epic"],
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "child",
+    direction: "directed",
+    inverse: "parent",
+    ordering: false,
+    hierarchy: true,
+    hierarchyDirection: "source_parent",
+    outgoing: "many",
+    incoming: "one",
+    lifecycle: "supersedable",
+    aliases: ["parent_child", "task"],
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "related",
+    direction: "undirected",
+    ordering: false,
+    hierarchy: false,
+    outgoing: "many",
+    incoming: "many",
+    lifecycle: "persistent",
+    aliases: ["related_to"],
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "discovered_from",
+    direction: "directed",
+    ordering: false,
+    hierarchy: false,
+    outgoing: "many",
+    incoming: "many",
+    lifecycle: "persistent",
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "incident_from",
+    direction: "directed",
+    ordering: false,
+    hierarchy: false,
+    outgoing: "many",
+    incoming: "many",
+    lifecycle: "persistent",
+    compatibilityVersion: 1,
+    allowSelf: false
+  },
+  {
+    kind: "supersedes",
+    direction: "directed",
+    ordering: false,
+    hierarchy: false,
+    outgoing: "many",
+    incoming: "many",
+    lifecycle: "supersedable",
+    compatibilityVersion: 1,
+    allowSelf: false
+  }
+];
+function normalizeKind(kind) {
+  return kind.trim().toLowerCase().replaceAll("-", "_");
+}
+function normalizeInverseKind(inverse) {
+  if (inverse === void 0)
+    return void 0;
+  const normalized = normalizeKind(inverse);
+  if (!/^[a-z][a-z0-9_]*$/.test(normalized))
+    throw new TypeError(`Invalid inverse relationship kind: ${inverse}`);
+  return normalized;
+}
+function freezeValue(value, visited = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (visited.has(value))
+    return value;
+  visited.add(value);
+  if (Array.isArray(value)) {
+    for (const entry of value)
+      freezeValue(entry, visited);
+    return Object.freeze(value);
+  }
+  for (const entry of Object.values(value))
+    freezeValue(entry, visited);
+  return Object.freeze(value);
+}
+function assertRelationshipPrecedence(definition, kind) {
+  if (definition.precedence !== void 0 && definition.precedence !== "source_before_target" && definition.precedence !== "target_before_source")
+    throw new TypeError(`Invalid relationship precedence for ${kind}`);
+  if (!definition.ordering && definition.precedence !== void 0)
+    throw new TypeError(`Non-ordering relationship kind cannot declare precedence: ${kind}`);
+}
+function assertRelationshipHierarchyDirection(definition, kind) {
+  if (definition.hierarchyDirection !== void 0 && definition.hierarchyDirection !== "source_parent" && definition.hierarchyDirection !== "target_parent")
+    throw new TypeError(`Invalid relationship hierarchy direction for ${kind}`);
+  if (!definition.hierarchy && definition.hierarchyDirection !== void 0)
+    throw new TypeError(`Non-hierarchy relationship kind cannot declare hierarchy direction: ${kind}`);
+}
+var RelationshipKindRegistry = class {
+  #definitions = /* @__PURE__ */ new Map();
+  #aliases = /* @__PURE__ */ new Map();
+  /** Create a registry initialized with the stable built-in ontology by default. */
+  constructor(definitions = BUILTIN_RELATIONSHIP_KINDS) {
+    for (const definition of definitions)
+      this.register(definition);
+  }
+  /** Register one definition after validating its identifier, version, and aliases. */
+  register(definition) {
+    const kind = normalizeKind(definition.kind);
+    if (!/^[a-z][a-z0-9_]*$/.test(kind))
+      throw new TypeError(`Invalid relationship kind: ${definition.kind}`);
+    if (!Number.isInteger(definition.compatibilityVersion) || definition.compatibilityVersion < 1)
+      throw new TypeError(`Invalid compatibility version for ${kind}`);
+    assertRelationshipPrecedence(definition, kind);
+    assertRelationshipHierarchyDirection(definition, kind);
+    if (this.#definitions.has(kind) || this.#aliases.has(kind))
+      throw new TypeError(`Relationship kind already registered: ${kind}`);
+    const inverse = normalizeInverseKind(definition.inverse);
+    const aliases = [
+      ...new Set((definition.aliases ?? []).map(normalizeKind))
+    ].sort();
+    for (const alias of aliases) {
+      if (!/^[a-z][a-z0-9_]*$/.test(alias))
+        throw new TypeError(`Invalid relationship alias: ${alias}`);
+      if (alias === kind || this.#definitions.has(alias) || this.#aliases.has(alias))
+        throw new TypeError(`Relationship alias already registered: ${alias}`);
+    }
+    const normalized = Object.freeze({
+      ...definition,
+      kind,
+      inverse,
+      aliases: Object.freeze(aliases),
+      payloadSchema: definition.payloadSchema ? freezeValue(structuredClone(definition.payloadSchema)) : void 0
+    });
+    this.#definitions.set(kind, normalized);
+    for (const alias of aliases)
+      this.#aliases.set(alias, kind);
+    return this;
+  }
+  /** Resolve a canonical kind or compatibility alias. */
+  resolve(kind) {
+    if (typeof kind !== "string")
+      return void 0;
+    const normalized = normalizeKind(kind);
+    return this.#definitions.get(this.#aliases.get(normalized) ?? normalized);
+  }
+  /** Resolve a kind or throw a precise error suitable for command adapters. */
+  require(kind) {
+    const definition = this.resolve(kind);
+    if (!definition)
+      throw new TypeError(`Unknown relationship kind: ${kind}`);
+    return definition;
+  }
+  /** Return a deterministic immutable registry snapshot. */
+  list() {
+    return Object.freeze([...this.#definitions.values()].sort((left, right) => left.kind.localeCompare(right.kind)));
+  }
+};
+function createRelationshipKindRegistry() {
+  return new RelationshipKindRegistry();
+}
+var defaultRegistry = createRelationshipKindRegistry();
+function isOrderingRelationshipKind(kind, registry = defaultRegistry) {
+  return registry.resolve(kind)?.ordering === true;
+}
+function compareEdges(left, right) {
+  return left.source.localeCompare(right.source) || left.target.localeCompare(right.target) || left.kind.localeCompare(right.kind);
+}
+function normalizeRelationshipEdge(candidate, nodes, registry) {
+  const source = typeof candidate.source === "string" ? candidate.source.trim() : "";
+  const target = typeof candidate.target === "string" ? candidate.target.trim() : "";
+  const definition = registry.require(candidate.kind);
+  if (!nodes.has(source) || !nodes.has(target))
+    throw new TypeError(`Relationship endpoint not found: ${source} -> ${target}`);
+  if (source === target && !definition.allowSelf)
+    throw new TypeError(`Self relationship is not allowed for ${definition.kind}`);
+  const edge = Object.freeze({
+    ...candidate,
+    source,
+    target,
+    kind: definition.kind
+  });
+  const endpoints = definition.direction === "undirected" ? [source, target].sort().join("\0") : `${source}\0${target}`;
+  return { edge, identity: `${definition.kind}\0${endpoints}` };
+}
+function appendIndexedEdge(index, node, edge) {
+  const indexed = index.get(node);
+  if (indexed)
+    indexed.push(edge);
+  else
+    index.set(node, [edge]);
+}
+function normalizeNodeId(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function resolveExistingNodeId(value, ids) {
+  const id = normalizeNodeId(value);
+  return id && ids.has(id) ? id : void 0;
+}
+function reconstructPath(source, target, parents) {
+  const path = [target];
+  let cursor = target;
+  while (cursor !== source) {
+    cursor = parents.get(cursor);
+    path.push(cursor);
+  }
+  return path.reverse();
+}
+var RelationshipGraph = class _RelationshipGraph {
+  #registry;
+  #nodes;
+  #nodeSnapshot;
+  #edges;
+  #outgoing = /* @__PURE__ */ new Map();
+  #incoming = /* @__PURE__ */ new Map();
+  /** Validate and index nodes and edges without reading tracker storage. */
+  constructor(nodes, edges, registry = defaultRegistry) {
+    this.#registry = registry;
+    this.#nodes = new Set([...nodes].filter((id) => typeof id === "string").map((id) => id.trim()).filter(Boolean));
+    this.#nodeSnapshot = Object.freeze([...this.#nodes].sort());
+    const deduped = /* @__PURE__ */ new Map();
+    for (const candidate of edges) {
+      const { edge, identity } = normalizeRelationshipEdge(candidate, this.#nodes, registry);
+      deduped.set(identity, edge);
+    }
+    this.#edges = Object.freeze([...deduped.values()].sort(compareEdges));
+    for (const edge of this.#edges) {
+      appendIndexedEdge(this.#outgoing, edge.source, edge);
+      appendIndexedEdge(this.#incoming, edge.target, edge);
+      if (registry.require(edge.kind).direction === "undirected") {
+        appendIndexedEdge(this.#outgoing, edge.target, edge);
+        appendIndexedEdge(this.#incoming, edge.source, edge);
+      }
+    }
+  }
+  /** Build the graph directly from item metadata, including hierarchy and legacy blocker fields. */
+  static fromItems(items, registry = defaultRegistry) {
+    const ids = new Set(items.map((item) => normalizeNodeId(item.id)).filter(Boolean));
+    const edges = [];
+    for (const item of items) {
+      const source = normalizeNodeId(item.id);
+      if (!source)
+        continue;
+      const parent = resolveExistingNodeId(item.parent, ids);
+      if (parent)
+        edges.push({ source, target: parent, kind: "parent" });
+      const blockedBy = resolveExistingNodeId(item.blocked_by, ids);
+      if (blockedBy)
+        edges.push({
+          source,
+          target: blockedBy,
+          kind: "blocked_by"
+        });
+      for (const dependency of item.dependencies ?? []) {
+        const dependencyId = resolveExistingNodeId(dependency.id, ids);
+        if (dependencyId && registry.resolve(dependency.kind))
+          edges.push({
+            source,
+            target: dependencyId,
+            kind: dependency.kind,
+            createdAt: dependency.created_at,
+            author: dependency.author
+          });
+      }
+    }
+    return new _RelationshipGraph(ids, edges, registry);
+  }
+  /** Return the deterministic immutable edge snapshot. */
+  edges() {
+    return this.#edges;
+  }
+  /** Return the deterministic immutable edges incident to one node. */
+  incidentEdges(id) {
+    this.#assertNode(id);
+    const outgoing = this.#outgoing.get(id) ?? [];
+    const incoming = this.#incoming.get(id) ?? [];
+    if (outgoing.length === 0)
+      return Object.freeze([...incoming]);
+    if (incoming.length === 0)
+      return Object.freeze([...outgoing]);
+    const edges = [];
+    let outgoingIndex = 0;
+    let incomingIndex = 0;
+    while (outgoingIndex < outgoing.length || incomingIndex < incoming.length) {
+      const outgoingEdge = outgoing[outgoingIndex];
+      const incomingEdge = incoming[incomingIndex];
+      const edge = outgoingEdge === void 0 ? incomingEdge : incomingEdge === void 0 || compareEdges(outgoingEdge, incomingEdge) <= 0 ? outgoingEdge : incomingEdge;
+      if (edges.at(-1) !== edge)
+        edges.push(edge);
+      if (outgoingEdge === edge)
+        outgoingIndex += 1;
+      if (incomingEdge === edge)
+        incomingIndex += 1;
+    }
+    return Object.freeze(edges);
+  }
+  /** Return the deterministic immutable node snapshot. */
+  nodes() {
+    return this.#nodeSnapshot;
+  }
+  #assertNode(id) {
+    if (!this.#nodes.has(id))
+      throw new TypeError(`Relationship node not found: ${id}`);
+  }
+  #matchesKinds(edge, kinds) {
+    if (!kinds)
+      return true;
+    const definition = this.#registry.require(edge.kind);
+    return kinds.has(edge.kind) || definition.inverse !== void 0 && kinds.has(definition.inverse);
+  }
+  #neighbors(id, direction, kinds) {
+    const candidates = [
+      ...direction === "incoming" ? [] : this.#outgoing.get(id) ?? [],
+      ...direction === "outgoing" ? [] : this.#incoming.get(id) ?? []
+    ];
+    return [...new Set(candidates)].filter((edge) => this.#matchesKinds(edge, kinds)).map((edge) => ({
+      id: edge.source === id ? edge.target : edge.source,
+      edge
+    })).sort((left, right) => left.id.localeCompare(right.id) || compareEdges(left.edge, right.edge));
+  }
+  /** Return one-hop adjacent node identifiers. */
+  adjacency(id, options = {}) {
+    this.#assertNode(id);
+    options.signal?.throwIfAborted();
+    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
+    const rows = this.#neighbors(id, options.direction ?? "outgoing", kinds);
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    const uniqueNeighbors = [...new Set(rows.map((row) => row.id))];
+    const value = uniqueNeighbors.slice(0, limit);
+    return {
+      value,
+      meta: {
+        visitedNodes: 1,
+        inspectedEdges: rows.length,
+        truncated: value.length < uniqueNeighbors.length,
+        nextCursor: value.at(-1)
+      }
+    };
+  }
+  /** Return bounded transitive closure in breadth-first discovery order. */
+  closure(id, options = {}) {
+    this.#assertNode(id);
+    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
+    const direction = options.direction ?? "outgoing";
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+    const seen = /* @__PURE__ */ new Set([id]);
+    const value = [];
+    const queue = [{ id, depth: 0 }];
+    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 neighbors = this.#neighbors(current.id, direction, kinds);
+      inspectedEdges += neighbors.length;
+      if (current.depth >= maxDepth) {
+        if (neighbors.some((neighbor) => !seen.has(neighbor.id)))
+          truncated = true;
+        continue;
+      }
+      for (const neighbor of neighbors) {
+        if (seen.has(neighbor.id))
+          continue;
+        if (value.length >= limit) {
+          truncated = true;
+          break traversal;
+        }
+        seen.add(neighbor.id);
+        value.push(neighbor.id);
+        queue.push({ id: neighbor.id, depth: current.depth + 1 });
+      }
+    }
+    return {
+      value,
+      meta: {
+        visitedNodes,
+        inspectedEdges,
+        truncated,
+        nextCursor: value.at(-1)
+      }
+    };
+  }
+  /** Return a deterministic shortest path, or an empty array when disconnected. */
+  shortestPath(source, target, options = {}) {
+    this.#assertNode(source);
+    this.#assertNode(target);
+    if (source === target)
+      return {
+        value: [source],
+        meta: { visitedNodes: 1, inspectedEdges: 0, truncated: false }
+      };
+    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
+    const direction = options.direction ?? "outgoing";
+    const maxDepth = options.maxDepth ?? Number.POSITIVE_INFINITY;
+    const queue = [{ id: source, depth: 0 }];
+    const parents = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set([source]);
+    let visitedNodes = 0;
+    let inspectedEdges = 0;
+    let truncated = false;
+    for (let index = 0; index < queue.length; index += 1) {
+      options.signal?.throwIfAborted();
+      const current = queue[index];
+      visitedNodes += 1;
+      const neighbors = this.#neighbors(current.id, direction, kinds);
+      inspectedEdges += neighbors.length;
+      if (current.depth >= maxDepth) {
+        if (neighbors.some((neighbor) => !seen.has(neighbor.id)))
+          truncated = true;
+        continue;
+      }
+      for (const neighbor of neighbors) {
+        if (seen.has(neighbor.id))
+          continue;
+        parents.set(neighbor.id, current.id);
+        if (neighbor.id === target)
+          return {
+            value: reconstructPath(source, target, parents),
+            meta: { visitedNodes, inspectedEdges, truncated: false }
+          };
+        seen.add(neighbor.id);
+        queue.push({ id: neighbor.id, depth: current.depth + 1 });
+      }
+    }
+    return {
+      value: [],
+      meta: { visitedNodes, inspectedEdges, truncated }
+    };
+  }
+  /** Return the induced subgraph over a bounded closure including the root. */
+  subgraph(id, options = {}) {
+    const closure = this.closure(id, options);
+    const nodes = [id, ...closure.value].sort();
+    const included = new Set(nodes);
+    const kinds = options.kinds ? new Set(options.kinds.map((kind) => this.#registry.require(kind).kind)) : void 0;
+    const edges = /* @__PURE__ */ new Set();
+    for (const node of nodes) {
+      for (const edge of this.#outgoing.get(node) ?? []) {
+        if (included.has(edge.source) && included.has(edge.target) && this.#matchesKinds(edge, kinds))
+          edges.add(edge);
+      }
+    }
+    return {
+      value: {
+        nodes,
+        edges: [...edges].sort(compareEdges)
+      },
+      meta: closure.meta
+    };
+  }
+};
+function dependencyToRelationship(source, dependency, registry = defaultRegistry) {
+  return {
+    source,
+    target: dependency.id,
+    kind: registry.require(dependency.kind).kind,
+    createdAt: dependency.created_at,
+    author: dependency.author
+  };
+}
+
+// dist/sdk/relationship-context.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "dfd47ca8-a68d-50e1-9aba-638d974a0027");
+  } catch (e2) {
+  }
+})();
+var tokenEncoder = new TextEncoder();
+function positiveInteger(value, fallback, field) {
+  const resolved = value ?? fallback;
+  if (!Number.isInteger(resolved) || resolved < 1)
+    throw new TypeError(`Relationship context ${field} must be positive`);
+  return resolved;
+}
+function estimateTokens(value) {
+  return Math.max(1, Math.ceil(tokenEncoder.encode(JSON.stringify(value)).byteLength / 4));
+}
+function explainDirectEdge(edge, root, node, registry) {
+  const definition = registry.require(edge.kind);
+  if (definition.ordering) {
+    const sourceFirst = (definition.precedence ?? "source_before_target") === "source_before_target";
+    const before = sourceFirst ? edge.source : edge.target;
+    return node === before ? "prerequisite" : "dependent";
+  }
+  if (definition.hierarchy) {
+    const sourceIsParent = (definition.hierarchyDirection ?? "source_parent") === "source_parent";
+    const parent = sourceIsParent ? edge.source : edge.target;
+    return node === parent ? "ancestor" : "descendant";
+  }
+  if (edge.kind === "discovered_from" || edge.kind === "incident_from")
+    return "provenance";
+  return "related";
+}
+function directReasons(rootEdges, root, node, registry) {
+  const reasons = rootEdges.filter((edge) => edge.source === root && edge.target === node || edge.target === root && edge.source === node).map((edge) => explainDirectEdge(edge, root, node, registry));
+  return [...new Set(reasons)].sort();
+}
+function discoverNodes(graph, root, options) {
+  const direction = options.direction ?? "both";
+  const maxDepth = options.maxDepth ?? 3;
+  if (!Number.isInteger(maxDepth) || maxDepth < 0)
+    throw new TypeError("Relationship context maxDepth must be non-negative");
+  const seen = /* @__PURE__ */ new Set([root]);
+  const queue = [{ id: root, distance: 0 }];
+  const rows = [];
+  let inspectedEdges = 0;
+  let depthTruncated = false;
+  for (let index = 0; index < queue.length; index += 1) {
+    options.signal?.throwIfAborted();
+    const current = queue[index];
+    if (current.distance >= maxDepth && depthTruncated)
+      continue;
+    const adjacent = graph.adjacency(current.id, {
+      direction,
+      kinds: options.kinds,
+      signal: options.signal
+    });
+    inspectedEdges += adjacent.meta.inspectedEdges;
+    if (current.distance >= maxDepth) {
+      if (adjacent.value.some((id) => !seen.has(id)))
+        depthTruncated = true;
+      continue;
+    }
+    for (const id of adjacent.value) {
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      const row = { id, distance: current.distance + 1 };
+      rows.push(row);
+      queue.push(row);
+    }
+  }
+  rows.sort((left, right) => left.distance - right.distance || left.id.localeCompare(right.id));
+  return {
+    rows,
+    visitedNodes: queue.length,
+    inspectedEdges,
+    depthTruncated
+  };
+}
+function selectContextNodes(params) {
+  const nodes = [];
+  let usedTokens = params.initialTokens;
+  const rootEdges = params.graph.incidentEdges(params.rootId);
+  for (const candidate of params.candidates) {
+    if (nodes.length >= params.nodeLimit)
+      break;
+    const node = {
+      ...params.details.get(candidate.id) ?? { id: candidate.id },
+      distance: candidate.distance,
+      reasons: candidate.distance === 1 ? directReasons(rootEdges, params.rootId, candidate.id, params.registry) : [`reachable at depth ${candidate.distance}`]
+    };
+    const cost = estimateTokens(node);
+    if (usedTokens + cost > params.tokenBudget)
+      break;
+    nodes.push(node);
+    usedTokens += cost;
+  }
+  if (params.candidates.length > 0 && nodes.length === 0)
+    throw new TypeError("Relationship context tokenBudget cannot fit one node");
+  return { nodes, usedTokens };
+}
+function selectContextEdges(params) {
+  const candidates = params.graph.edges().filter((edge) => params.included.has(edge.source) && params.included.has(edge.target));
+  const edges = [];
+  let usedTokens = params.initialTokens;
+  for (const edge of candidates) {
+    if (edges.length >= params.edgeLimit)
+      break;
+    const cost = estimateTokens(edge);
+    if (usedTokens + cost > params.tokenBudget)
+      break;
+    edges.push(edge);
+    usedTokens += cost;
+  }
+  return { edges, usedTokens, candidateCount: candidates.length };
+}
+function buildRelationshipContext(graph, rootId, details, options = {}) {
+  if (!graph.nodes().includes(rootId))
+    throw new TypeError(`Relationship node not found: ${rootId}`);
+  const nodeLimit = positiveInteger(options.nodeLimit, 20, "nodeLimit");
+  const edgeLimit = positiveInteger(options.edgeLimit, 40, "edgeLimit");
+  const tokenBudget = positiveInteger(options.tokenBudget, 1200, "tokenBudget");
+  const registry = options.registry ?? createRelationshipKindRegistry();
+  const byId = new Map(details.map((detail) => [detail.id, detail]));
+  const rootDetails = byId.get(rootId) ?? {
+    id: rootId
+  };
+  const { evidence: rootEvidence = [], ...root } = rootDetails;
+  const evidence = [...rootEvidence];
+  const discovery = discoverNodes(graph, rootId, options);
+  const fingerprint = createQueryFingerprint("relationship-context", {
+    rootId,
+    direction: options.direction ?? "both",
+    kinds: [...options.kinds ?? []].sort(),
+    maxDepth: options.maxDepth ?? 3
+  });
+  const pageStart = resolveQueryCursorStart(discovery.rows, options.cursor, fingerprint, ({ id }) => id);
+  const candidates = discovery.rows.slice(pageStart);
+  const initialTokens = estimateTokens(root) + estimateTokens(evidence);
+  if (initialTokens > tokenBudget)
+    throw new TypeError("Relationship context tokenBudget cannot fit root and evidence");
+  const nodeSelection = selectContextNodes({
+    candidates,
+    details: byId,
+    graph,
+    rootId,
+    registry,
+    nodeLimit,
+    tokenBudget,
+    initialTokens
+  });
+  const { nodes } = nodeSelection;
+  const included = /* @__PURE__ */ new Set([rootId, ...nodes.map(({ id }) => id)]);
+  const edgeSelection = selectContextEdges({
+    graph,
+    included,
+    edgeLimit,
+    tokenBudget,
+    initialTokens: nodeSelection.usedTokens
+  });
+  const { edges, usedTokens } = edgeSelection;
+  const consumed = pageStart + nodes.length;
+  const hasMoreNodes = consumed < discovery.rows.length;
+  const lastNode = nodes.at(-1);
+  const omittedEdges = edgeSelection.candidateCount - edges.length;
+  const truncated = discovery.depthTruncated || hasMoreNodes || omittedEdges > 0;
+  return {
+    root,
+    nodes,
+    edges,
+    evidence,
+    meta: {
+      exact: true,
+      truncated,
+      nodeLimit,
+      edgeLimit,
+      tokenBudget,
+      usedTokens,
+      visitedNodes: discovery.visitedNodes,
+      inspectedEdges: discovery.inspectedEdges,
+      omittedNodes: discovery.rows.length - consumed,
+      omittedEdges,
+      ...hasMoreNodes && lastNode ? {
+        nextCursor: encodeQueryCursor(fingerprint, lastNode.id, consumed - 1)
+      } : {}
+    }
+  };
+}
+
+// dist/sdk/dependencies.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f44a0567-53d9-5c87-b01f-15fb84782227");
+  } catch (e2) {
+  }
+})();
+var DEPS_FORMAT_VALUES = ["tree", "graph", "context"];
+var DEPS_COLLAPSE_VALUES = ["none", "repeated"];
+function normalizeDependencyReferenceTarget(target) {
+  if (typeof target !== "string")
+    return void 0;
+  const normalized = target.trim();
+  if (!normalized || ["none", "null", "n/a", "na"].includes(normalized.toLowerCase()))
+    return void 0;
+  return normalized;
+}
+function normalizeDependencyGraphTarget(target) {
+  const normalized = normalizeDependencyReferenceTarget(target);
+  return normalized?.toLowerCase() === "no-active-blocker" ? void 0 : normalized;
+}
+function collectDanglingDependencyReferences(items, isTerminal = (status) => status === "closed" || status === "canceled") {
+  const knownIds = new Set(items.map((item) => item.id.trim().toLowerCase()));
+  const rows = /* @__PURE__ */ new Map();
+  const addReference = (item, target, kind, source) => {
+    const normalized = normalizeDependencyReferenceTarget(target);
+    if (!normalized || knownIds.has(normalized.toLowerCase())) {
+      return;
+    }
+    const row = {
+      holder_id: item.id,
+      target_id: normalized,
+      kind,
+      source,
+      holder_status: item.status,
+      legacy_terminal: isTerminal(item.status),
+      no_active_blocker_sentinel: normalized.toLowerCase() === "no-active-blocker"
+    };
+    rows.set(`${row.holder_id}::${row.target_id}::${row.kind}::${row.source}`, row);
+  };
+  for (const item of items) {
+    addReference(item, item.parent, "parent", "parent");
+    addReference(item, item.blocked_by, "blocked_by", "blocked_by");
+    for (const dependency of item.dependencies ?? []) {
+      if (typeof dependency !== "object" || dependency === null) {
+        continue;
+      }
+      const legacyDependency = dependency;
+      addReference(item, legacyDependency.id, typeof legacyDependency.kind === "string" ? legacyDependency.kind : "related", "dependency");
+    }
+  }
+  const sorted = [...rows.values()].sort((left, right) => left.holder_id.localeCompare(right.holder_id) || left.target_id.localeCompare(right.target_id) || left.kind.localeCompare(right.kind) || left.source.localeCompare(right.source));
+  const legacyTerminal = sorted.filter((row) => row.legacy_terminal);
+  return {
+    active: sorted.filter((row) => !row.legacy_terminal),
+    legacy_terminal: legacyTerminal,
+    no_active_blocker_sentinels: sorted.filter((row) => row.no_active_blocker_sentinel)
+  };
+}
+function collectMissingDependencyTargetIds(dangling) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const reference of [...dangling.active, ...dangling.legacy_terminal]) {
+    if (reference.no_active_blocker_sentinel)
+      continue;
+    const target = reference.target_id.trim();
+    const key = target.toLowerCase();
+    if (!targets.has(key))
+      targets.set(key, target);
+  }
+  return [...targets.values()].sort((left, right) => left.localeCompare(right));
+}
+function parseFormat(raw) {
+  const candidate = raw?.trim().toLowerCase() ?? "tree";
+  if (DEPS_FORMAT_VALUES.includes(candidate)) {
+    return candidate;
+  }
+  throw new PmCliError(`Invalid --format value "${raw}". Use "tree", "graph", or "context".`, EXIT_CODE.USAGE);
+}
+function parsePositiveInteger(raw, flag) {
+  if (raw === void 0)
+    return void 0;
+  const value = typeof raw === "number" ? raw : Number(raw.trim());
+  if (!Number.isInteger(value) || value < 1)
+    throw new PmCliError(`Invalid --${flag} value "${raw}". Use a positive integer.`, EXIT_CODE.USAGE);
+  return value;
+}
+function parseMaxDepth(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = typeof raw === "number" ? raw : Number(raw.trim());
+  if (!Number.isInteger(normalized) || normalized < 0) {
+    throw new PmCliError(`Invalid --max-depth value "${raw}". Use a non-negative integer.`, EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseCollapse(raw) {
+  const candidate = raw?.trim().toLowerCase() ?? "none";
+  if (DEPS_COLLAPSE_VALUES.includes(candidate)) {
+    return candidate;
+  }
+  throw new PmCliError(`Invalid --collapse value "${raw}". Use "none" or "repeated".`, EXIT_CODE.USAGE);
+}
+function normalizeDependencies(dependencies) {
+  if (!dependencies || dependencies.length === 0) {
+    return [];
+  }
+  const sorted = dependencies.map(({ id, kind }) => ({
+    id: id.trim(),
+    kind: kind.trim().toLowerCase()
+  })).sort((left, right) => {
+    const byKind = left.kind.localeCompare(right.kind);
+    if (byKind !== 0)
+      return byKind;
+    return left.id.localeCompare(right.id);
+  });
+  const deduped = /* @__PURE__ */ new Map();
+  for (const dependency of sorted) {
+    const key = `${dependency.kind.toLowerCase()}::${dependency.id.toLowerCase()}`;
+    if (!deduped.has(key)) {
+      deduped.set(key, { id: dependency.id, kind: dependency.kind });
+    }
+  }
+  return [...deduped.values()];
+}
+function toIndexedItem(item) {
+  return {
+    id: item.id,
+    title: item.title,
+    type: item.type,
+    status: item.status,
+    dependencies: normalizeDependencies(item.dependencies)
+  };
+}
+function toTreeNode(id, index, lineage, maxDepth, collapse, expanded, depth = 0, via) {
+  const lookupId = id.trim().toLowerCase();
+  const item = index.get(lookupId);
+  const baseNode = {
+    id: item?.id ?? id,
+    title: item?.title,
+    type: item?.type,
+    status: item?.status,
+    via,
+    missing: !item,
+    cycle: lineage.has(lookupId),
+    dependencies: []
+  };
+  if (!item || baseNode.cycle) {
+    return baseNode;
+  }
+  if (maxDepth !== void 0 && depth >= maxDepth) {
+    if (item.dependencies.length > 0) {
+      baseNode.truncated = true;
+    }
+    return baseNode;
+  }
+  if (collapse === "repeated" && expanded.has(lookupId)) {
+    baseNode.collapsed = true;
+    return baseNode;
+  }
+  if (collapse === "repeated") {
+    expanded.add(lookupId);
+  }
+  const nextLineage = new Set(lineage);
+  nextLineage.add(lookupId);
+  baseNode.dependencies = item.dependencies.map((dependency) => toTreeNode(dependency.id, index, nextLineage, maxDepth, collapse, expanded, depth + 1, dependency.kind));
+  return baseNode;
+}
+function mergeGraphNode(existing, candidate) {
+  if (!existing) {
+    return candidate;
+  }
+  if (existing.missing && !candidate.missing)
+    return candidate;
+  return {
+    ...existing,
+    title: existing.title ?? candidate.title,
+    type: existing.type ?? candidate.type,
+    status: existing.status ?? candidate.status
+  };
+}
+function toGraph(root) {
+  const nodesById = /* @__PURE__ */ new Map();
+  const edgesByKey = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    nodesById.set(node.id, mergeGraphNode(nodesById.get(node.id), {
+      id: node.id,
+      title: node.title,
+      type: node.type,
+      status: node.status,
+      missing: node.missing
+    }));
+    for (const child of node.dependencies) {
+      nodesById.set(child.id, mergeGraphNode(nodesById.get(child.id), {
+        id: child.id,
+        title: child.title,
+        type: child.type,
+        status: child.status,
+        missing: child.missing
+      }));
+      const relationKind = child.via ?? "related";
+      const edgeKey = `${node.id}::${child.id}::${relationKind}`;
+      if (!edgesByKey.has(edgeKey)) {
+        edgesByKey.set(edgeKey, {
+          from: node.id,
+          to: child.id,
+          kind: relationKind
+        });
+      }
+      if (!child.cycle) {
+        visit(child);
+      }
+    }
+  };
+  visit(root);
+  const nodes = [...nodesById.values()].sort((left, right) => left.id.localeCompare(right.id));
+  const edges = [...edgesByKey.values()].sort((left, right) => {
+    const byFrom = left.from.localeCompare(right.from);
+    if (byFrom !== 0)
+      return byFrom;
+    const byTo = left.to.localeCompare(right.to);
+    if (byTo !== 0)
+      return byTo;
+    return left.kind.localeCompare(right.kind);
+  });
+  const missingIds = nodes.filter((node) => node.missing).map((node) => node.id);
+  return {
+    root_id: root.id,
+    nodes,
+    edges,
+    missing_ids: missingIds
+  };
+}
+function countDependencyGraph(rootId, index, maxDepth) {
+  const nodeIds = /* @__PURE__ */ new Set();
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const missingIds = /* @__PURE__ */ new Set();
+  const expanded = /* @__PURE__ */ new Set();
+  const pending = [{ id: rootId, depth: 0 }];
+  let pendingIndex = 0;
+  while (pendingIndex < pending.length) {
+    const current = pending[pendingIndex++];
+    const lookupId = current.id.trim().toLowerCase();
+    nodeIds.add(lookupId);
+    const item = index.get(lookupId);
+    if (!item) {
+      missingIds.add(lookupId);
+      continue;
+    }
+    if (maxDepth !== void 0 && current.depth >= maxDepth) {
+      continue;
+    }
+    if (expanded.has(lookupId)) {
+      continue;
+    }
+    expanded.add(lookupId);
+    for (const dependency of item.dependencies) {
+      edgeKeys.add(`${lookupId}::${dependency.id.trim().toLowerCase()}::${dependency.kind}`);
+      pending.push({ id: dependency.id, depth: current.depth + 1 });
+    }
+  }
+  return {
+    node_count: nodeIds.size,
+    edge_count: edgeKeys.size,
+    missing_count: missingIds.size
+  };
+}
+function buildDepsRelationshipContext(rootId, items, options) {
+  const maxDepth = parseMaxDepth(options.maxDepth);
+  const nodeLimit = parsePositiveInteger(options.nodeLimit, "node-limit");
+  const edgeLimit = parsePositiveInteger(options.edgeLimit, "edge-limit");
+  const tokenBudget = parsePositiveInteger(options.tokenBudget, "token-budget");
+  const canonicalIds = new Map(items.map((item) => [item.id.trim().toLowerCase(), item.id.trim()]));
+  const dangling = collectDanglingDependencyReferences(items);
+  const missingIds = collectMissingDependencyTargetIds(dangling);
+  const graphItems = items.map((item) => {
+    const parent = normalizeDependencyGraphTarget(item.parent);
+    const blocker = normalizeDependencyGraphTarget(item.blocked_by);
+    const dependencies = (item.dependencies ?? []).flatMap((rawDependency) => {
+      if (typeof rawDependency !== "object" || rawDependency === null)
+        return [];
+      const dependency = rawDependency;
+      const target = normalizeDependencyGraphTarget(dependency.id);
+      if (!target)
+        return [];
+      return [{
+        id: canonicalIds.get(target.toLowerCase()) ?? target,
+        kind: typeof dependency.kind === "string" ? dependency.kind : "related"
+      }];
+    });
+    return {
+      id: item.id,
+      ...parent ? { parent: canonicalIds.get(parent.toLowerCase()) ?? parent } : {},
+      ...blocker ? { blocked_by: canonicalIds.get(blocker.toLowerCase()) ?? blocker } : {},
+      dependencies
+    };
+  });
+  return buildRelationshipContext(RelationshipGraph.fromItems([...graphItems, ...missingIds.map((id) => ({ id }))]), rootId, [
+    ...items.map((item) => ({ id: item.id, title: item.title, status: item.status })),
+    ...missingIds.map((id) => ({ id, title: `[missing] ${id}`, status: "missing" }))
+  ], {
+    ...maxDepth === void 0 ? {} : { maxDepth },
+    ...nodeLimit === void 0 ? {} : { nodeLimit },
+    ...edgeLimit === void 0 ? {} : { edgeLimit },
+    ...tokenBudget === void 0 ? {} : { tokenBudget },
+    ...options.cursor?.trim() ? { cursor: options.cursor.trim() } : {}
+  });
+}
+async function runDeps(id, options, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const format = parseFormat(options.format);
+  const maxDepth = parseMaxDepth(options.maxDepth);
+  const collapse = parseCollapse(options.collapse);
+  const summaryOnly = options.summary === true;
+  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 index = new Map(items.map((item) => [item.id.trim().toLowerCase(), toIndexedItem(item)]));
+  const dangling = collectDanglingDependencyReferences(items, (status) => isTerminalStatus(status, statusRegistry));
+  for (const reference of [...dangling.active, ...dangling.legacy_terminal]) {
+    const holder = index.get(reference.holder_id.trim().toLowerCase());
+    const referenceKind = reference.kind.trim().toLowerCase();
+    if (holder && !holder.dependencies.some((dependency) => dependency.id.trim().toLowerCase() === reference.target_id.trim().toLowerCase() && dependency.kind === referenceKind)) {
+      holder.dependencies.push({ id: reference.target_id, kind: referenceKind });
+    }
+  }
+  if (!index.has(id.trim().toLowerCase())) {
+    throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+  }
+  if (format === "context") {
+    const canonicalId = index.get(id.trim().toLowerCase()).id;
+    const context = buildDepsRelationshipContext(canonicalId, items, options);
+    return {
+      id: canonicalId,
+      format,
+      node_count: context.nodes.length + 1,
+      edge_count: context.edges.length,
+      missing_count: collectMissingDependencyTargetIds(dangling).length,
+      ...summaryOnly ? {} : { context }
+    };
+  }
+  if (summaryOnly) {
+    return {
+      id,
+      format,
+      ...countDependencyGraph(id, index, maxDepth)
+    };
+  }
+  const tree = toTreeNode(id, index, /* @__PURE__ */ new Set(), maxDepth, collapse, /* @__PURE__ */ new Set());
+  const graph = toGraph(tree);
+  const baseResult = {
+    id,
+    format,
+    node_count: graph.nodes.length,
+    edge_count: graph.edges.length,
+    missing_count: graph.missing_ids.length
+  };
+  if (format === "tree") {
+    return {
+      ...baseResult,
+      tree
+    };
+  }
+  return {
+    ...baseResult,
+    graph
+  };
+}
+
+export {
+  RelationshipKindRegistry,
+  createRelationshipKindRegistry,
+  isOrderingRelationshipKind,
+  RelationshipGraph,
+  dependencyToRelationship,
+  buildRelationshipContext,
+  DEPS_FORMAT_VALUES,
+  DEPS_COLLAPSE_VALUES,
+  collectDanglingDependencyReferences,
+  buildDepsRelationshipContext,
+  runDeps
+};
+//# sourceMappingURL=chunk-BKVG6XOA.js.map