@unbrained/pm-cli 2026.7.16 → 2026.7.18

package/dist/sdk/dependencies.d.ts

@@ -1,5 +1,6 @@
 import type { GlobalOptions } from "../core/shared/command-types.js";
-import type { Dependency, ItemMetadata, ItemStatus, ItemType } from "../types/index.js";
+import type { ItemMetadata, ItemStatus, ItemType } from "../types/index.js";
+import { type DanglingDependencyReference } from "./graph/assembly.js";
 import { type RelationshipContextResult } from "./relationship-context.js";
 /** Supported values accepted by the deps format contract. */
 export declare const DEPS_FORMAT_VALUES: readonly ["tree", "graph", "context"];
@@ -9,6 +10,10 @@ export type DepsFormat = (typeof DEPS_FORMAT_VALUES)[number];
 export declare const DEPS_COLLAPSE_VALUES: readonly ["none", "repeated"];
 /** Restricts deps collapse mode values accepted by command, SDK, and storage contracts. */
 export type DepsCollapseMode = (typeof DEPS_COLLAPSE_VALUES)[number];
+/** Supported values accepted by the deps graph-context direction contract. */
+export declare const DEPS_DIRECTION_VALUES: readonly ["outgoing", "incoming", "both"];
+/** Restricts deps traversal-direction values accepted by command, SDK, and storage contracts. */
+export type DepsDirection = (typeof DEPS_DIRECTION_VALUES)[number];
 /** Documents the deps command options payload exchanged by command, SDK, and package integrations. */
 export interface DepsCommandOptions {
     /** Value that configures or reports format for this contract. */
@@ -21,62 +26,17 @@ export interface DepsCommandOptions {
     summary?: boolean;
     /** Maximum graph-context nodes returned. */
     nodeLimit?: string | number;
-    /** Maximum graph-context edges returned. */
+    /** Maximum graph-context edges and enumerated missing-reference rows returned. */
     edgeLimit?: string | number;
     /** Maximum estimated graph-context output tokens. */
     tokenBudget?: string | number;
     /** Opaque continuation cursor for graph-context output. */
     cursor?: string;
+    /** Graph-context traversal direction relative to each visited node. */
+    direction?: string;
+    /** Registered relationship kinds narrowing graph-context traversal. */
+    kind?: string | string[];
 }
-/** Minimal item shape inspected by dependency-reference governance. */
-export interface DependencyReferenceHolder {
-    /** Stable item identifier. */
-    id: string;
-    /** Lifecycle status used to separate actionable work from historical debt. */
-    status: ItemStatus;
-    /** Optional hierarchy parent reference. */
-    parent?: string;
-    /** Optional legacy scalar blocker reference. */
-    blocked_by?: string;
-    /** Structured dependency edges. */
-    dependencies?: Dependency[];
-}
-/** Storage surface that contributed a normalized dependency reference. */
-export type DependencyReferenceSource = "parent" | "blocked_by" | "dependency";
-/** One normalized dependency reference whose target is absent from the tracker. */
-export interface DanglingDependencyReference {
-    /** Item that owns the reference. */
-    holder_id: string;
-    /** Missing referenced item id or legacy sentinel. */
-    target_id: string;
-    /** Relationship field or dependency kind. */
-    kind: string;
-    /** Storage surface that owns the reference and determines its remediation. */
-    source: DependencyReferenceSource;
-    /** Current lifecycle status of the holder. */
-    holder_status: ItemStatus;
-    /** Whether the holder is terminal and therefore historical, non-actionable debt. */
-    legacy_terminal: boolean;
-    /** Whether the target is the pre-structured-dependency `no-active-blocker` sentinel. */
-    no_active_blocker_sentinel: boolean;
-}
-/** Actionable and historical partitions returned by dependency-reference governance. */
-export interface DanglingDependencyReferenceSummary {
-    /** Missing references held by active items; these may affect scheduling and should gate validation. */
-    active: DanglingDependencyReference[];
-    /** Missing references held only by terminal items; retained as informational history debt. */
-    legacy_terminal: DanglingDependencyReference[];
-    /** Legacy sentinel rows across active and terminal holders, called out separately from typo-like ids. */
-    no_active_blocker_sentinels: DanglingDependencyReference[];
-}
-/**
- * Classify missing hierarchy and dependency targets without mutating their holders.
- *
- * Consumers provide the workspace's terminal-status predicate so custom lifecycle
- * schemas receive the same active-versus-historical behavior as the built-in
- * closed/canceled statuses.
- */
-export declare function collectDanglingDependencyReferences(items: readonly DependencyReferenceHolder[], isTerminal?: (status: ItemStatus) => boolean): DanglingDependencyReferenceSummary;
 /** Documents the deps tree node payload exchanged by command, SDK, and package integrations. */
 export interface DepsTreeNode {
     /** Stable identifier used to reference this record across commands and storage. */
@@ -143,8 +103,22 @@ export interface DepsResult {
     node_count: number;
     /** Number of edge entries represented by this result. */
     edge_count: number;
-    /** Number of missing entries represented by this result. */
+    /**
+     * Number of missing entries represented by this result.
+     *
+     * Tree and graph formats count missing nodes encountered while walking
+     * dependency edges; context format counts missing nodes reachable within the
+     * same bounded traversal (direction, kinds, and depth) that produced the
+     * packet, independent of node or token pagination, so the two formats agree
+     * for equal traversal parameters over the dependency edge family.
+     */
     missing_count: number;
+    /** Traversal scope documenting the missing_count semantics for context format. */
+    missing_scope?: "traversal";
+    /** Total dangling references declared into the traversed missing nodes. */
+    missing_reference_count?: number;
+    /** Bounded enumeration of dangling references, capped by the context edge limit. */
+    missing_references?: DanglingDependencyReference[];
     /** Value that configures or reports tree for this contract. */
     tree?: DepsTreeNode;
     /** Value that configures or reports graph for this contract. */
@@ -152,7 +126,22 @@ export interface DepsResult {
     /** Explainable bounded graph-context projection. */
     context?: RelationshipContextResult;
 }
+/** Parse one positive-integer graph bound, failing fast with the offending flag name. */
+export declare function parsePositiveInteger(raw: string | number | undefined, flag: string): number | undefined;
+/** Parse the shared non-negative --max-depth traversal bound. */
+export declare function parseMaxDepth(raw: string | number | undefined): number | undefined;
+/** Parse the shared graph traversal --direction value, defaulting to "both". */
+export declare function parseDirection(raw: string | undefined): DepsDirection;
+/**
+ * Normalize repeatable and comma-separated --kind values against the built-in
+ * relationship ontology, failing fast on unknown kinds instead of silently
+ * matching nothing (the multi-value filter-grammar trap tracked by pm-gknu).
+ */
+export declare function parseKinds(raw: string | string[] | undefined): string[] | undefined;
+/** Options subset consumed by the deps graph-context projection. */
+type DepsContextOptions = Pick<DepsCommandOptions, "maxDepth" | "nodeLimit" | "edgeLimit" | "tokenBudget" | "cursor" | "direction" | "kind">;
 /** Build the SDK-backed bounded relationship-context projection for deps. */
-export declare function buildDepsRelationshipContext(rootId: string, items: readonly ItemMetadata[], options: Pick<DepsCommandOptions, "maxDepth" | "nodeLimit" | "edgeLimit" | "tokenBudget" | "cursor">): RelationshipContextResult;
+export declare function buildDepsRelationshipContext(rootId: string, items: readonly ItemMetadata[], options: DepsContextOptions, rootEvidence?: readonly string[]): RelationshipContextResult;
 /** Implements run deps for the public runtime surface of this module. */
 export declare function runDeps(id: string, options: DepsCommandOptions, global: GlobalOptions): Promise<DepsResult>;
+export {};

package/dist/sdk/dependencies.js

@@ -4,7 +4,7 @@
  * Implements the pm deps command surface and its agent-facing runtime behavior.
  */
 
-!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(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]="1f69c8aa-b089-5f6e-8b5a-63695f1e6bbf")}catch(e){}}();
 import { getActiveExtensionRegistrations } from "../core/extensions/index.js";
 import { pathExists } from "../core/fs/fs-utils.js";
 import { resolveItemTypeRegistry } from "../core/item/type-registry.js";
@@ -12,94 +12,19 @@ import { isTerminalStatus } from "../core/item/status.js";
 import { resolveRuntimeStatusRegistry } from "../core/schema/runtime-schema.js";
 import { EXIT_CODE } from "../core/shared/constants.js";
 import { PmCliError } from "../core/shared/errors.js";
-import { listAllItemMetadataLight } from "../core/store/item-store.js";
+import { listAllItemMetadataLight, locateItem, readLocatedItem, } from "../core/store/item-store.js";
 import { getSettingsPath, resolvePmRoot } from "../core/store/paths.js";
 import { readSettings } from "../core/store/settings.js";
+import { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, } from "./graph/assembly.js";
+import { computeWorkspaceGraphFingerprint, workspaceGraphCache, } from "./graph/cache.js";
 import { buildRelationshipContext, } from "./relationship-context.js";
-import { RelationshipGraph } from "./relationships.js";
+import { createRelationshipKindRegistry } from "./relationships.js";
 /** Supported values accepted by the deps format contract. */
 export const DEPS_FORMAT_VALUES = ["tree", "graph", "context"];
 /** Supported values accepted by the deps collapse contract. */
 export const DEPS_COLLAPSE_VALUES = ["none", "repeated"];
-/** Normalize a decoded reference target and reject empty legacy placeholders. */
-function normalizeDependencyReferenceTarget(target) {
-    if (typeof target !== "string")
-        return undefined;
-    const normalized = target.trim();
-    if (!normalized || ["none", "null", "n/a", "na"].includes(normalized.toLowerCase()))
-        return undefined;
-    return normalized;
-}
-/** Normalize a graph target while removing the historical no-blocker marker. */
-function normalizeDependencyGraphTarget(target) {
-    const normalized = normalizeDependencyReferenceTarget(target);
-    return normalized?.toLowerCase() === "no-active-blocker" ? undefined : normalized;
-}
-/**
- * Classify missing hierarchy and dependency targets without mutating their holders.
- *
- * Consumers provide the workspace's terminal-status predicate so custom lifecycle
- * schemas receive the same active-versus-historical behavior as the built-in
- * closed/canceled statuses.
- */
-export function collectDanglingDependencyReferences(items, isTerminal = (status) => status === "closed" || status === "canceled") {
-    const knownIds = new Set(items.map((item) => item.id.trim().toLowerCase()));
-    const rows = 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 ?? []) {
-            // Public SDK callers may supply legacy or JSON-decoded payloads that do
-            // not yet satisfy the current structured dependency contract.
-            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),
-    };
-}
-/** Return unique real missing targets while excluding the legacy no-blocker sentinel. */
-function collectMissingDependencyTargetIds(dangling) {
-    const targets = 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));
-}
+/** Supported values accepted by the deps graph-context direction contract. */
+export const DEPS_DIRECTION_VALUES = ["outgoing", "incoming", "both"];
 function parseFormat(raw) {
     const candidate = raw?.trim().toLowerCase() ?? "tree";
     if (DEPS_FORMAT_VALUES.includes(candidate)) {
@@ -107,7 +32,8 @@ function parseFormat(raw) {
     }
     throw new PmCliError(`Invalid --format value "${raw}". Use "tree", "graph", or "context".`, EXIT_CODE.USAGE);
 }
-function parsePositiveInteger(raw, flag) {
+/** Parse one positive-integer graph bound, failing fast with the offending flag name. */
+export function parsePositiveInteger(raw, flag) {
     if (raw === undefined)
         return undefined;
     const value = typeof raw === "number" ? raw : Number(raw.trim());
@@ -115,7 +41,8 @@ function parsePositiveInteger(raw, flag) {
         throw new PmCliError(`Invalid --${flag} value "${raw}". Use a positive integer.`, EXIT_CODE.USAGE);
     return value;
 }
-function parseMaxDepth(raw) {
+/** Parse the shared non-negative --max-depth traversal bound. */
+export function parseMaxDepth(raw) {
     if (raw === undefined) {
         return undefined;
     }
@@ -132,6 +59,43 @@ function parseCollapse(raw) {
     }
     throw new PmCliError(`Invalid --collapse value "${raw}". Use "none" or "repeated".`, EXIT_CODE.USAGE);
 }
+/** Parse the shared graph traversal --direction value, defaulting to "both". */
+export 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);
+}
+/**
+ * Normalize repeatable and comma-separated --kind values against the built-in
+ * relationship ontology, failing fast on unknown kinds instead of silently
+ * matching nothing (the multi-value filter-grammar trap tracked by pm-gknu).
+ */
+export function parseKinds(raw) {
+    if (raw === undefined)
+        return undefined;
+    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 undefined;
+    const kinds = 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 [];
@@ -303,47 +267,130 @@ function countDependencyGraph(rootId, index, maxDepth) {
         missing_count: missingIds.size,
     };
 }
-/** Build the SDK-backed bounded relationship-context projection for deps. */
-export function buildDepsRelationshipContext(rootId, items, options) {
+/** Parse CLI-compatible deps context options once for packet and closure parity. */
+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 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" })),
-    ], {
+    const kinds = parseKinds(options.kind);
+    return {
+        direction: parseDirection(options.direction),
+        ...(kinds === undefined ? {} : { kinds }),
         ...(maxDepth === undefined ? {} : { maxDepth }),
         ...(nodeLimit === undefined ? {} : { nodeLimit }),
         ...(edgeLimit === undefined ? {} : { edgeLimit }),
         ...(tokenBudget === undefined ? {} : { tokenBudget }),
         ...(options.cursor?.trim() ? { cursor: options.cursor.trim() } : {}),
+    };
+}
+/** Build one bounded context packet from an assembled deps relationship graph. */
+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);
+}
+/** Build the SDK-backed bounded relationship-context projection for deps. */
+export function buildDepsRelationshipContext(rootId, items, options, rootEvidence = []) {
+    return buildContextFromAssembly(assembleWorkspaceRelationshipGraph(items), rootId, parseDepsContextOptions(options), rootEvidence);
+}
+/** Append up to `limit` labeled pointers from one linked collection. */
+function appendEvidencePointers(evidence, label, values, limit) {
+    for (const value of values.slice(0, limit)) {
+        const trimmed = value?.trim();
+        if (trimmed)
+            evidence.push(`${label}:${trimmed}`);
+    }
+}
+/**
+ * Load bounded root evidence pointers (linked files, tests, docs, and
+ * annotation counts) so the context packet answers "where is the proof"
+ * without a follow-up item read.
+ */
+async function collectRootEvidence(pmRoot, id, settings, typeToFolder) {
+    const located = await locateItem(pmRoot, id, settings.id_prefix, settings.item_format, typeToFolder);
+    // The caller already resolved the root against the light index, so a miss
+    // can only happen when storage mutates mid-read; degrade to no evidence.
+    /* c8 ignore start -- defensive: unreachable without a concurrent delete between the index scan and this read. */
+    if (!located)
+        return [];
+    /* c8 ignore stop */
+    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;
+}
+/** Assemble the context-format deps result with traversal-scoped missing enumeration. */
+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 === undefined
+            ? {}
+            : { 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))
+        : undefined;
+    const packetIds = 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 === undefined)
+            return true;
+        const definition = relationshipRegistry.resolve(row.kind);
+        return (definition !== undefined &&
+            (filteredKinds.has(definition.kind) ||
+                (definition.inverse !== undefined &&
+                    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,
+            }),
+    };
 }
 /** Implements run deps for the public runtime surface of this module. */
 export async function runDeps(id, options, global) {
@@ -375,15 +422,20 @@ export async function runDeps(id, options, global) {
     }
     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 }),
-        };
+        const rootEvidence = summaryOnly
+            ? []
+            : await collectRootEvidence(pmRoot, canonicalId, settings, typeRegistry.type_to_folder);
+        const isTerminal = (status) => isTerminalStatus(status, statusRegistry);
+        // Reuse the fingerprint-keyed shared cache so bounded context packets in
+        // long-lived hosts stop paying full-workspace assembly on every call.
+        const lookup = workspaceGraphCache().lookup(pmRoot, computeWorkspaceGraphFingerprint(items, isTerminal), () => assembleWorkspaceRelationshipGraph(items, isTerminal));
+        return buildContextDepsResult({
+            assembly: lookup.assembly,
+            canonicalId,
+            options,
+            rootEvidence,
+            summaryOnly,
+        });
     }
     if (summaryOnly) {
         return {
@@ -413,4 +465,4 @@ export async function runDeps(id, options, global) {
     };
 }
 //# sourceMappingURL=dependencies.js.map
-//# debugId=f44a0567-53d9-5c87-b01f-15fb84782227
+//# debugId=1f69c8aa-b089-5f6e-8b5a-63695f1e6bbf