@unbrained/pm-cli 2026.7.16 → 2026.7.18

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

@@ -0,0 +1,783 @@
+
+!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]="bc45de9b-3efd-5b0c-b660-483700eabaa9")}catch(e){}}();
+import {
+  assembleWorkspaceRelationshipGraph,
+  collectDanglingDependencyReferences,
+  createRelationshipKindRegistry
+} from "./chunk-L5BTTDU5.js";
+import {
+  createQueryFingerprint,
+  encodeQueryCursor,
+  resolveQueryCursorStart
+} from "./chunk-2IPNL3DR.js";
+import {
+  getActiveExtensionRegistrations,
+  isTerminalStatus,
+  listAllItemMetadataLight,
+  locateItem,
+  readLocatedItem,
+  readSettings
+} from "./chunk-P22HGFFI.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  getSettingsPath,
+  pathExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeStatusRegistry
+} from "./chunk-KX62NMZC.js";
+
+// dist/sdk/graph/cache.js
+import { createHash } from "node:crypto";
+var DEFAULT_MAX_RESULTS_PER_WORKSPACE = 64;
+var DEFAULT_MAX_WORKSPACES = 8;
+function fingerprintLine(item, isTerminal) {
+  const dependencies = (item.dependencies ?? []).map((rawDependency) => {
+    if (typeof rawDependency !== "object" || rawDependency === null)
+      return "";
+    const dependency = rawDependency;
+    return `${typeof dependency.kind === "string" ? dependency.kind : "related"}:${typeof dependency.id === "string" ? dependency.id : ""}`;
+  }).sort().join(",");
+  return [
+    item.id,
+    item.title,
+    item.status,
+    isTerminal(item.status) ? "1" : "0",
+    item.parent ?? "",
+    item.blocked_by ?? "",
+    dependencies
+  ].join("\0");
+}
+function computeWorkspaceGraphFingerprint(items, isTerminal = (status) => status === "closed" || status === "canceled") {
+  const lines = items.filter((item) => typeof item?.id === "string" && item.id.trim().length > 0).map((item) => fingerprintLine(item, isTerminal)).sort();
+  return createHash("sha256").update(lines.join("
")).digest("hex");
+}
+function requirePositiveCacheBound(name, value, fallback) {
+  const bound = value ?? fallback;
+  if (!Number.isInteger(bound) || bound < 1)
+    throw new TypeError(`Invalid ${name} bound: ${String(value)}`);
+  return bound;
+}
+var WorkspaceGraphCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  #maxResultsPerWorkspace;
+  #maxWorkspaces;
+  /** Create a cache, optionally bounding workspaces and memoized results. */
+  constructor(options = {}) {
+    this.#maxResultsPerWorkspace = requirePositiveCacheBound("maxResultsPerWorkspace", options.maxResultsPerWorkspace, DEFAULT_MAX_RESULTS_PER_WORKSPACE);
+    this.#maxWorkspaces = requirePositiveCacheBound("maxWorkspaces", options.maxWorkspaces, DEFAULT_MAX_WORKSPACES);
+  }
+  /**
+   * Resolve the cached assembly for one workspace key and fingerprint,
+   * building and storing it on miss. The returned lookup exposes snapshot-
+   * scoped memoization for query results derived from the same assembly.
+   */
+  lookup(key, fingerprint, build) {
+    let entry = this.#entries.get(key);
+    let assemblyReused = true;
+    if (entry === void 0 || entry.fingerprint !== fingerprint) {
+      entry = { fingerprint, assembly: build(), results: /* @__PURE__ */ new Map() };
+      assemblyReused = false;
+      if (!this.#entries.has(key) && this.#entries.size >= this.#maxWorkspaces) {
+        this.#entries.delete(this.#entries.keys().next().value);
+      }
+    }
+    this.#entries.delete(key);
+    this.#entries.set(key, entry);
+    const resolved = entry;
+    const maxResults = this.#maxResultsPerWorkspace;
+    return {
+      assembly: resolved.assembly,
+      assemblyReused,
+      fingerprint,
+      memoize(queryKey, compute) {
+        const cached = resolved.results.get(queryKey);
+        if (cached !== void 0 || resolved.results.has(queryKey)) {
+          resolved.results.delete(queryKey);
+          resolved.results.set(queryKey, cached);
+          return { value: structuredClone(cached), reused: true };
+        }
+        const value = compute();
+        if (resolved.results.size >= maxResults) {
+          resolved.results.delete(resolved.results.keys().next().value);
+        }
+        resolved.results.set(queryKey, structuredClone(value));
+        return { value, reused: false };
+      }
+    };
+  }
+  /** Drop every cached workspace entry and memoized result. */
+  clear() {
+    this.#entries.clear();
+  }
+};
+var sharedCache = new WorkspaceGraphCache();
+function workspaceGraphCache() {
+  return sharedCache;
+}
+function resetWorkspaceGraphCache() {
+  sharedCache.clear();
+}
+
+// dist/sdk/relationship-context.js
+var RELATIONSHIP_CONTEXT_ROLE_PRIORITY = [
+  "prerequisite",
+  "dependent",
+  "ancestor",
+  "descendant",
+  "provenance",
+  "related"
+];
+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, node, registry) {
+  const definition = registry.resolve(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, node, registry));
+  return [...new Set(reasons)].sort();
+}
+function primaryRole(roles) {
+  return RELATIONSHIP_CONTEXT_ROLE_PRIORITY.find((role) => roles.includes(role));
+}
+function discoverNodes(graph, root, registry, 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.neighborEdges(current.id, {
+      direction,
+      kinds: options.kinds,
+      signal: options.signal
+    });
+    inspectedEdges += adjacent.meta.inspectedEdges;
+    if (current.distance >= maxDepth) {
+      if (adjacent.value.some((row) => !seen.has(row.id)))
+        depthTruncated = true;
+      continue;
+    }
+    for (const { id, edge } of adjacent.value) {
+      if (seen.has(id))
+        continue;
+      seen.add(id);
+      const row = {
+        id,
+        distance: current.distance + 1,
+        via: current.id,
+        role: explainDirectEdge(edge, id, registry)
+      };
+      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 summarizeDirectEdges(graph, root, registry, options) {
+  const directEdges = {
+    prerequisite: 0,
+    dependent: 0,
+    ancestor: 0,
+    descendant: 0,
+    provenance: 0,
+    related: 0
+  };
+  const rows = graph.neighborEdges(root, {
+    direction: options.direction ?? "both",
+    kinds: options.kinds,
+    signal: options.signal
+  }).value;
+  for (const { id, edge } of rows)
+    directEdges[explainDirectEdge(edge, id, registry)] += 1;
+  return {
+    directEdges,
+    directTotal: rows.length,
+    rootEdges: rows.map(({ edge }) => edge)
+  };
+}
+function selectContextNodes(params) {
+  const nodes = [];
+  let usedTokens = params.initialTokens;
+  for (const candidate of params.candidates) {
+    if (nodes.length >= params.nodeLimit)
+      break;
+    const direct = candidate.distance === 1 ? directReasons(params.rootEdges, params.rootId, candidate.id, params.registry) : [];
+    const node = {
+      ...params.details.get(candidate.id) ?? { id: candidate.id },
+      distance: candidate.distance,
+      role: direct.length > 0 ? primaryRole(direct) : candidate.role,
+      via: candidate.via,
+      reasons: direct.length > 0 ? direct : [
+        `${candidate.role} via ${candidate.via} (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 kinds = params.options.kinds ? new Set(params.options.kinds.map((kind) => params.registry.require(kind).kind)) : void 0;
+  const candidates = params.graph.edges().filter((edge) => {
+    if (!params.included.has(edge.source) || !params.included.has(edge.target))
+      return false;
+    if (kinds === void 0 || kinds.has(edge.kind))
+      return true;
+    const inverse = params.registry.resolve(edge.kind)?.inverse;
+    return inverse !== void 0 && kinds.has(inverse);
+  });
+  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, registry, options);
+  const { rootEdges, ...directSummary } = summarizeDirectEdges(graph, rootId, registry, 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,
+    rootEdges,
+    rootId,
+    registry,
+    nodeLimit,
+    tokenBudget,
+    initialTokens
+  });
+  const { nodes } = nodeSelection;
+  const included = /* @__PURE__ */ new Set([rootId, ...nodes.map(({ id }) => id)]);
+  const edgeSelection = selectContextEdges({
+    graph,
+    included,
+    options,
+    registry,
+    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;
+  const summary = {
+    rootId,
+    ...root.status === void 0 ? {} : { rootStatus: root.status },
+    ...directSummary,
+    discoveredNodes: discovery.rows.length,
+    returnedNodes: nodes.length,
+    returnedEdges: edges.length,
+    omittedNodes: discovery.rows.length - consumed,
+    omittedEdges,
+    evidenceCount: evidence.length,
+    hasMore: hasMoreNodes
+  };
+  return {
+    root,
+    summary,
+    nodes,
+    edges,
+    evidence,
+    meta: {
+      exact: true,
+      truncated,
+      completeness: truncated ? "truncated" : "complete",
+      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"];
+var DEPS_DIRECTION_VALUES = ["outgoing", "incoming", "both"];
+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 parseDirection(raw) {
+  const candidate = raw?.trim().toLowerCase() ?? "both";
+  if (DEPS_DIRECTION_VALUES.includes(candidate)) {
+    return candidate;
+  }
+  throw new PmCliError(`Invalid --direction value "${raw}". Use "outgoing", "incoming", or "both".`, EXIT_CODE.USAGE);
+}
+function parseKinds(raw) {
+  if (raw === void 0)
+    return void 0;
+  const registry = createRelationshipKindRegistry();
+  const values = (Array.isArray(raw) ? raw : [raw]).flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+  if (values.length === 0)
+    return void 0;
+  const kinds = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const definition = registry.resolve(value);
+    if (!definition) {
+      const known = registry.list().map((entry) => entry.kind).join(", ");
+      throw new PmCliError(`Invalid --kind value "${value}". Registered kinds: ${known}.`, EXIT_CODE.USAGE);
+    }
+    kinds.add(definition.kind);
+  }
+  return [...kinds].sort();
+}
+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 parseDepsContextOptions(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 kinds = parseKinds(options.kind);
+  return {
+    direction: parseDirection(options.direction),
+    ...kinds === void 0 ? {} : { kinds },
+    ...maxDepth === void 0 ? {} : { maxDepth },
+    ...nodeLimit === void 0 ? {} : { nodeLimit },
+    ...edgeLimit === void 0 ? {} : { edgeLimit },
+    ...tokenBudget === void 0 ? {} : { tokenBudget },
+    ...options.cursor?.trim() ? { cursor: options.cursor.trim() } : {}
+  };
+}
+function buildContextFromAssembly(assembly, rootId, options, rootEvidence) {
+  return buildRelationshipContext(assembly.graph, rootId, assembly.details.map((detail) => detail.id === rootId && rootEvidence.length > 0 ? { ...detail, evidence: rootEvidence } : detail), options);
+}
+function buildDepsRelationshipContext(rootId, items, options, rootEvidence = []) {
+  return buildContextFromAssembly(assembleWorkspaceRelationshipGraph(items), rootId, parseDepsContextOptions(options), rootEvidence);
+}
+function appendEvidencePointers(evidence, label, values, limit) {
+  for (const value of values.slice(0, limit)) {
+    const trimmed = value?.trim();
+    if (trimmed)
+      evidence.push(`${label}:${trimmed}`);
+  }
+}
+async function collectRootEvidence(pmRoot, id, settings, typeToFolder) {
+  const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
+  if (!located)
+    return [];
+  const { document } = await readLocatedItem(located, {
+    schema: settings.schema
+  });
+  const metadata = document.metadata;
+  const files = metadata.files ?? [];
+  const tests = metadata.tests ?? [];
+  const docs = metadata.docs ?? [];
+  const counts = [
+    ["files", files.length],
+    ["tests", tests.length],
+    ["docs", docs.length],
+    ["comments", (metadata.comments ?? []).length],
+    ["notes", (metadata.notes ?? []).length],
+    ["learnings", (metadata.learnings ?? []).length]
+  ];
+  if (counts.every(([, count]) => count === 0))
+    return [];
+  const evidence = [
+    `linked:${counts.map(([key, count]) => `${key}=${count}`).join(",")}`
+  ];
+  appendEvidencePointers(evidence, "file", files.map((file) => file.path), 3);
+  appendEvidencePointers(evidence, "test", tests.map((test) => test.command ?? test.path), 2);
+  appendEvidencePointers(evidence, "doc", docs.map((doc) => doc.path), 2);
+  return evidence;
+}
+function buildContextDepsResult(params) {
+  const { assembly, canonicalId, options, rootEvidence, summaryOnly } = params;
+  const contextOptions = parseDepsContextOptions(options);
+  const context = buildContextFromAssembly(assembly, canonicalId, contextOptions, rootEvidence);
+  const reachable = assembly.graph.closure(canonicalId, {
+    direction: contextOptions.direction,
+    ...contextOptions.kinds === void 0 ? {} : { kinds: contextOptions.kinds },
+    maxDepth: contextOptions.maxDepth ?? 3
+  });
+  const missingReachable = reachable.value.filter((nodeId) => assembly.missingIdSet.has(nodeId.toLowerCase()));
+  const missingReachableSet = new Set(missingReachable.map((nodeId) => nodeId.toLowerCase()));
+  const relationshipRegistry = createRelationshipKindRegistry();
+  const filteredKinds = contextOptions.kinds ? new Set(contextOptions.kinds.map((kind) => relationshipRegistry.require(kind).kind)) : void 0;
+  const packetIds = /* @__PURE__ */ new Set([canonicalId, ...reachable.value]);
+  const missingReferences = [
+    ...assembly.dangling.active,
+    ...assembly.dangling.legacy_terminal
+  ].filter((row) => {
+    if (row.no_active_blocker_sentinel || !missingReachableSet.has(row.target_id.trim().toLowerCase()) || !packetIds.has(row.holder_id))
+      return false;
+    if (filteredKinds === void 0)
+      return true;
+    const definition = relationshipRegistry.resolve(row.kind);
+    return definition !== void 0 && (filteredKinds.has(definition.kind) || definition.inverse !== void 0 && filteredKinds.has(definition.inverse));
+  });
+  const referenceLimit = contextOptions.edgeLimit ?? 40;
+  return {
+    id: canonicalId,
+    format: "context",
+    node_count: context.nodes.length + 1,
+    edge_count: context.edges.length,
+    missing_count: missingReachable.length,
+    missing_scope: "traversal",
+    missing_reference_count: missingReferences.length,
+    ...summaryOnly ? {} : {
+      missing_references: missingReferences.slice(0, referenceLimit),
+      context
+    }
+  };
+}
+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 rootEvidence = summaryOnly ? [] : await collectRootEvidence(pmRoot, canonicalId, settings, typeRegistry.type_to_folder);
+    const isTerminal = (status) => isTerminalStatus(status, statusRegistry);
+    const lookup = workspaceGraphCache().lookup(pmRoot, computeWorkspaceGraphFingerprint(items, isTerminal), () => assembleWorkspaceRelationshipGraph(items, isTerminal));
+    return buildContextDepsResult({
+      assembly: lookup.assembly,
+      canonicalId,
+      options,
+      rootEvidence,
+      summaryOnly
+    });
+  }
+  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 {
+  computeWorkspaceGraphFingerprint,
+  WorkspaceGraphCache,
+  workspaceGraphCache,
+  resetWorkspaceGraphCache,
+  buildRelationshipContext,
+  DEPS_FORMAT_VALUES,
+  DEPS_COLLAPSE_VALUES,
+  DEPS_DIRECTION_VALUES,
+  parsePositiveInteger,
+  parseMaxDepth,
+  parseDirection,
+  parseKinds,
+  buildDepsRelationshipContext,
+  runDeps
+};
+//# sourceMappingURL=chunk-EX7OQT3Y.js.map
+
+//# debugId=bc45de9b-3efd-5b0c-b660-483700eabaa9