@unbrained/pm-cli 2026.7.18 → 2026.7.19

package/dist/cli-bundle/chunks/{chunk-KX62NMZC.js → chunk-D35WYXWC.js}

@@ -1,6 +1,6 @@
 // dist/core/fs/fs-utils.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]="a5eddd91-53f1-5292-9781-c74192041379")}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]="236f0bc3-3408-510b-9449-4755558bc2fb")}catch(e){}}();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -195,6 +195,7 @@ var KNOWN_EXTENSION_POLICY_SURFACES = [
   "schema.flags",
   "schema.itemfields",
   "schema.itemtypes",
+  "schema.relationshipkinds",
   "schema.migrations",
   "schema.profiles",
   "parser.override",
@@ -1516,7 +1517,7 @@ function validateTypeOptions(typeName, rawTypeOptions, registry) {
 }
 
 // dist/core/store/paths.js
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
 import os from "node:os";
 import path3 from "node:path";
 var ITEM_FILE_EXTENSION_BY_FORMAT = {
@@ -1527,6 +1528,12 @@ var ITEM_FORMAT_BY_EXTENSION = {
   ".md": "json_markdown",
   ".toon": "toon"
 };
+var NEARBY_TRACKER_SCAN_IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  "coverage",
+  "dist",
+  "node_modules"
+]);
 var ITEM_FILE_EXTENSIONS = [".md", ".toon"];
 function pathExists2(pathValue) {
   try {
@@ -1566,6 +1573,14 @@ function discoverPmRootFromAncestors(cwd) {
     current = parent;
   }
 }
+function discoverNearbyPmRoot(cwd, excludedRoot) {
+  const normalizedExcluded = excludedRoot ? path3.resolve(excludedRoot) : void 0;
+  try {
+    return readdirSync(path3.resolve(cwd), { withFileTypes: true }).filter((entry) => entry.isDirectory() && !NEARBY_TRACKER_SCAN_IGNORED_DIRECTORIES.has(entry.name)).map((entry) => path3.join(path3.resolve(cwd), entry.name)).filter((candidate) => candidate !== normalizedExcluded).filter((candidate) => pathExists2(getSettingsPath(candidate))).filter((candidate) => isPmSettingsFile(getSettingsPath(candidate))).sort((left, right) => left.localeCompare(right))[0];
+  } catch {
+    return void 0;
+  }
+}
 function resolvePmRoot(cwd, cliPath) {
   const envPath = process.env.PM_PATH;
   const explicitPath = cliPath?.trim() || envPath?.trim();
@@ -1724,6 +1739,572 @@ function asRecordClone(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : {};
 }
 
+// dist/sdk/relationships.js
+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}`);
+}
+function normalizeRelationshipKindIdentifier(definition) {
+  if (typeof definition !== "object" || definition === null)
+    throw new TypeError("Relationship kind definition requires an object");
+  if (typeof definition.kind !== "string")
+    throw new TypeError("Relationship kind requires a string identifier");
+  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}`);
+  return kind;
+}
+function assertRelationshipKindSemantics(definition, kind) {
+  if (!["directed", "undirected"].includes(definition.direction))
+    throw new TypeError(`Invalid relationship direction for ${kind}`);
+  if (typeof definition.ordering !== "boolean")
+    throw new TypeError(`Invalid relationship ordering flag for ${kind}`);
+  if (![void 0, true, false].includes(definition.hierarchy))
+    throw new TypeError(`Invalid relationship hierarchy flag for ${kind}`);
+  if (!["one", "many"].includes(definition.outgoing))
+    throw new TypeError(`Invalid outgoing relationship cardinality for ${kind}`);
+  if (!["one", "many"].includes(definition.incoming))
+    throw new TypeError(`Invalid incoming relationship cardinality for ${kind}`);
+  if (!["persistent", "supersedable", "ephemeral"].includes(definition.lifecycle))
+    throw new TypeError(`Invalid relationship lifecycle for ${kind}`);
+  if (typeof definition.allowSelf !== "boolean")
+    throw new TypeError(`Invalid relationship self-edge flag for ${kind}`);
+}
+function assertRelationshipKindPayload(definition, kind) {
+  if (definition.payloadSchema !== void 0 && (typeof definition.payloadSchema !== "object" || definition.payloadSchema === null || Array.isArray(definition.payloadSchema)))
+    throw new TypeError(`Invalid relationship payload schema for ${kind}`);
+  if (definition.aliases !== void 0 && (!Array.isArray(definition.aliases) || definition.aliases.some((alias) => typeof alias !== "string")))
+    throw new TypeError(`Invalid relationship aliases for ${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 = normalizeRelationshipKindIdentifier(definition);
+    assertRelationshipKindSemantics(definition, kind);
+    assertRelationshipKindPayload(definition, 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,
+      hierarchy: definition.hierarchy ?? false,
+      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 path7 = [target];
+  let cursor = target;
+  while (cursor !== source) {
+    cursor = parents.get(cursor);
+    path7.push(cursor);
+  }
+  return path7.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;
+  }
+  /** Report whether an identifier names an indexed node. */
+  hasNode(id) {
+    return this.#nodes.has(id);
+  }
+  /** Return the registry that interprets this graph's relationship kinds. */
+  registry() {
+    return this.#registry;
+  }
+  #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 deterministic one-hop neighbor rows paired with each connecting edge. */
+  neighborEdges(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 value = rows.slice(0, limit);
+    return {
+      value,
+      meta: {
+        visitedNodes: 1,
+        inspectedEdges: rows.length,
+        truncated: value.length < rows.length,
+        nextCursor: value.at(-1)?.id
+      }
+    };
+  }
+  /** 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/core/shared/levenshtein.js
 function levenshteinDistanceWithinLimit(left, right, limit) {
   if (left === right) {
@@ -1941,6 +2522,7 @@ function createEmptyExtensionRegistrationRegistry() {
     flags: [],
     item_fields: [],
     item_types: [],
+    relationship_kinds: [],
     migrations: [],
     profiles: [],
     importers: [],
@@ -2038,7 +2620,8 @@ async function runCommandHandler(commands, context) {
       args: cloneContextSnapshot(context.args),
       options: cloneContextSnapshot(context.options),
       global: cloneContextSnapshot(context.global),
-      pm_root: context.pm_root
+      pm_root: context.pm_root,
+      ...context.sdk === void 0 ? {} : { sdk: context.sdk }
     });
     return {
       handled: true,
@@ -4442,6 +5025,7 @@ var ExtensionApiRegistrar = class {
     this.registerFlags = this.registerFlags.bind(this);
     this.registerItemFields = this.registerItemFields.bind(this);
     this.registerItemTypes = this.registerItemTypes.bind(this);
+    this.registerRelationshipKinds = this.registerRelationshipKinds.bind(this);
     this.registerMigration = this.registerMigration.bind(this);
     this.registerProfile = this.registerProfile.bind(this);
     this.registerRenderer = this.registerRenderer.bind(this);
@@ -4691,6 +5275,33 @@ var ExtensionApiRegistrar = class {
       types: normalizedTypes
     });
   }
+  registerRelationshipKinds(definitions) {
+    assertExtensionCapability(this.#loadedExtension, "schema", "registerRelationshipKinds");
+    if (!this.allowRegistration("schema.relationshipkinds", "registerRelationshipKinds", "schema")) {
+      return;
+    }
+    if (!Array.isArray(definitions)) {
+      throw new TypeError("registerRelationshipKinds definitions requires an array of object definitions");
+    }
+    if (definitions.length === 0) {
+      throw new TypeError("registerRelationshipKinds requires at least one definition");
+    }
+    const registry = createRelationshipKindRegistry();
+    for (const registration of this.#registrationRegistry.relationship_kinds) {
+      for (const definition of registration.definitions) {
+        registry.register(definition);
+      }
+    }
+    const validated = definitions.map((definition) => {
+      registry.register(definition);
+      return registry.require(definition.kind);
+    });
+    this.#registrationRegistry.relationship_kinds.push({
+      layer: this.#loadedExtension.layer,
+      name: this.#loadedExtension.name,
+      definitions: validated
+    });
+  }
   registerMigration(definition) {
     assertExtensionCapability(this.#loadedExtension, "schema", "registerMigration");
     if (!this.allowRegistration("schema.migrations", "registerMigration", "schema")) {
@@ -4924,11 +5535,13 @@ function getRegistrationCounts(registrations) {
   const flagCount = registrations.flags.reduce((total, entry) => total + entry.flags.length, 0);
   const itemFieldCount = registrations.item_fields.reduce((total, entry) => total + entry.fields.length, 0);
   const itemTypeCount = registrations.item_types.reduce((total, entry) => total + entry.types.length, 0);
+  const relationshipKindCount = (registrations.relationship_kinds ?? []).reduce((total, entry) => total + entry.definitions.length, 0);
   return {
     commands: commandCount,
     flags: flagCount,
     item_fields: itemFieldCount,
     item_types: itemTypeCount,
+    ...relationshipKindCount > 0 ? { relationship_kinds: relationshipKindCount } : {},
     migrations: registrations.migrations.length,
     profiles: registrations.profiles.length,
     importers: registrations.importers.length,
@@ -5126,6 +5739,7 @@ var EXTENSION_CAPABILITY_REGISTRATION_SURFACES = {
     "registerFlags",
     "registerItemFields",
     "registerItemTypes",
+    "registerRelationshipKinds",
     "registerMigration",
     "registerProfile"
   ],
@@ -5178,6 +5792,7 @@ function attributeCapabilityUsage(activation) {
   record(registrations.flags, "schema");
   record(registrations.item_fields, "schema");
   record(registrations.item_types, "schema");
+  record(registrations.relationship_kinds ?? [], "schema");
   record(registrations.migrations, "schema");
   record(registrations.profiles, "schema");
   record(registrations.importers, "importers");
@@ -6144,6 +6759,7 @@ export {
   resolveCommandOptionPolicyState,
   validateTypeOptions,
   ITEM_FILE_EXTENSIONS,
+  discoverNearbyPmRoot,
   resolvePmRoot,
   resolveWorkspaceRoot,
   resolveGlobalPmRoot,
@@ -6179,6 +6795,11 @@ export {
   levenshteinDistanceWithinLimit,
   evaluatePmMinVersionBound,
   evaluatePmMaxVersionBound,
+  RelationshipKindRegistry,
+  createRelationshipKindRegistry,
+  isOrderingRelationshipKind,
+  RelationshipGraph,
+  dependencyToRelationship,
   normalizeKnownExtensionCapability,
   resolveLegacyExtensionCapabilityAlias,
   parseUnknownExtensionCapabilityWarning,
@@ -6234,6 +6855,6 @@ export {
   parseRegisteredItemFieldAssignments,
   applyRegisteredItemFieldDefaultsAndValidation
 };
-//# sourceMappingURL=chunk-KX62NMZC.js.map
+//# sourceMappingURL=chunk-D35WYXWC.js.map
 
-//# debugId=a5eddd91-53f1-5292-9781-c74192041379
+//# debugId=236f0bc3-3408-510b-9449-4755558bc2fb