@unbrained/pm-cli 2026.7.16 → 2026.7.18

package/dist/cli-bundle/chunks/{chunk-WQPUU7XD.js → chunk-L337QKWJ.js}

@@ -2,7 +2,7 @@
 !function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6697a54d-d56f-5a86-bbb2-7c12fef13cfe")}catch(e){}}();
 import {
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-2VPAVL7O.js";
+} from "./chunk-CKX4WOPC.js";
 import {
   applyHistoryPatch,
   cloneEmptyReplayDocument,
@@ -15,7 +15,7 @@ import {
   toReplayDocument,
   verifyHistoryChain,
   writeHistoryRawWithRollback
-} from "./chunk-GOSLKLFE.js";
+} from "./chunk-KH6QAHME.js";
 import {
   resolveAuthor
 } from "./chunk-CUFW7ITY.js";
@@ -28,7 +28,7 @@ import {
   readSettings,
   runActiveOnReadHooks,
   runActiveOnWriteHooks
-} from "./chunk-Q7A43DS4.js";
+} from "./chunk-P22HGFFI.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -38,7 +38,7 @@ import {
   resolveItemTypeRegistry,
   resolvePmRoot,
   resolveRuntimeStatusRegistry
-} from "./chunk-QKECXBBG.js";
+} from "./chunk-KX62NMZC.js";
 
 // dist/sdk/history-compact.js
 import fs from "node:fs/promises";
@@ -584,6 +584,6 @@ export {
   assertHistoryCompactTarget,
   runHistoryCompactBulk
 };
-//# sourceMappingURL=chunk-WQPUU7XD.js.map
+//# sourceMappingURL=chunk-L337QKWJ.js.map
 
 //# debugId=6697a54d-d56f-5a86-bbb2-7c12fef13cfe

package/dist/cli-bundle/chunks/{chunk-JFTKLTEF.js → chunk-L5BTTDU5.js}

@@ -1,27 +1,6 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fd394844-de95-5cab-9dd6-7c4ef4e52320")}catch(e){}}();
-import {
-  createQueryFingerprint,
-  encodeQueryCursor,
-  resolveQueryCursorStart
-} from "./chunk-HDH3JUGG.js";
-import {
-  getActiveExtensionRegistrations,
-  isTerminalStatus,
-  listAllItemMetadataLight,
-  readSettings
-} from "./chunk-Q7A43DS4.js";
-import {
-  EXIT_CODE,
-  PmCliError,
-  getSettingsPath,
-  pathExists,
-  resolveItemTypeRegistry,
-  resolvePmRoot,
-  resolveRuntimeStatusRegistry
-} from "./chunk-QKECXBBG.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]="8145f80d-99b5-53e4-a519-54b4549dca6c")}catch(e){}}();
 var BUILTIN_RELATIONSHIP_KINDS = [
   {
     kind: "blocked_by",
@@ -364,6 +343,14 @@ var RelationshipGraph = class _RelationshipGraph {
   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}`);
@@ -403,6 +390,24 @@ var RelationshipGraph = class _RelationshipGraph {
       }
     };
   }
+  /** 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);
@@ -528,193 +533,7 @@ function dependencyToRelationship(source, dependency, registry = defaultRegistry
   };
 }
 
-// dist/sdk/relationship-context.js
-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
-var DEPS_FORMAT_VALUES = ["tree", "graph", "context"];
-var DEPS_COLLAPSE_VALUES = ["none", "repeated"];
+// dist/sdk/graph/assembly.js
 function normalizeDependencyReferenceTarget(target) {
   if (typeof target !== "string")
     return void 0;
@@ -728,7 +547,8 @@ function normalizeDependencyGraphTarget(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 safeItems = items.filter((item) => typeof item?.id === "string" && item.id.trim().length > 0);
+  const knownIds = new Set(safeItems.map((item) => item.id.trim().toLowerCase()));
   const rows = /* @__PURE__ */ new Map();
   const addReference = (item, target, kind, source) => {
     const normalized = normalizeDependencyReferenceTarget(target);
@@ -736,7 +556,7 @@ function collectDanglingDependencyReferences(items, isTerminal = (status) => sta
       return;
     }
     const row = {
-      holder_id: item.id,
+      holder_id: item.id.trim(),
       target_id: normalized,
       kind,
       source,
@@ -746,7 +566,7 @@ function collectDanglingDependencyReferences(items, isTerminal = (status) => sta
     };
     rows.set(`${row.holder_id}::${row.target_id}::${row.kind}::${row.source}`, row);
   };
-  for (const item of items) {
+  for (const item of safeItems) {
     addReference(item, item.parent, "parent", "parent");
     addReference(item, item.blocked_by, "blocked_by", "blocked_by");
     for (const dependency of item.dependencies ?? []) {
@@ -777,211 +597,14 @@ function collectMissingDependencyTargetIds(dangling) {
   }
   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);
+function assembleWorkspaceRelationshipGraph(items, isTerminal, registry) {
+  const safeItems = items.filter((item) => typeof item?.id === "string" && item.id.trim().length > 0);
+  const canonicalIds = new Map(safeItems.map((item) => [item.id.trim().toLowerCase(), item.id.trim()]));
+  const dangling = collectDanglingDependencyReferences(safeItems, isTerminal);
   const missingIds = collectMissingDependencyTargetIds(dangling);
-  const graphItems = items.map((item) => {
+  for (const id of missingIds)
+    canonicalIds.set(id.toLowerCase(), id);
+  const graphItems = safeItems.map((item) => {
     const parent = normalizeDependencyGraphTarget(item.parent);
     const blocker = normalizeDependencyGraphTarget(item.blocked_by);
     const dependencies = (item.dependencies ?? []).flatMap((rawDependency) => {
@@ -991,91 +614,36 @@ function buildDepsRelationshipContext(rootId, items, options) {
       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: canonicalIds.get(target.toLowerCase()),
+          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 } : {},
+      id: item.id.trim(),
+      ...parent ? { parent: canonicalIds.get(parent.toLowerCase()) } : {},
+      ...blocker ? { blocked_by: canonicalIds.get(blocker.toLowerCase()) } : {},
       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, global) {
-  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 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
+    graph: RelationshipGraph.fromItems([...graphItems, ...missingIds.map((id) => ({ id }))], registry),
+    details: [
+      ...safeItems.map((item) => ({
+        id: item.id.trim(),
+        title: item.title,
+        status: item.status
+      })),
+      ...missingIds.map((id) => ({
+        id,
+        title: `[missing] ${id}`,
+        status: "missing"
+      }))
+    ],
+    missingIdSet: new Set(missingIds.map((id) => id.toLowerCase())),
+    dangling
   };
 }
 
@@ -1085,13 +653,10 @@ export {
   isOrderingRelationshipKind,
   RelationshipGraph,
   dependencyToRelationship,
-  buildRelationshipContext,
-  DEPS_FORMAT_VALUES,
-  DEPS_COLLAPSE_VALUES,
   collectDanglingDependencyReferences,
-  buildDepsRelationshipContext,
-  runDeps
+  collectMissingDependencyTargetIds,
+  assembleWorkspaceRelationshipGraph
 };
-//# sourceMappingURL=chunk-JFTKLTEF.js.map
+//# sourceMappingURL=chunk-L5BTTDU5.js.map
 
-//# debugId=fd394844-de95-5cab-9dd6-7c4ef4e52320
+//# debugId=8145f80d-99b5-53e4-a519-54b4549dca6c