@unbrained/pm-cli 2026.10.14 → 2026.10.15

package/dist/sdk/governance.d.ts

@@ -14,13 +14,13 @@ export * from "./governance/assurance-runtime.js";
 export * from "./governance/boundary-fixtures.js";
 export * from "./governance/defect-recurrence.js";
 export * from "./governance/defect-recurrence-coverage.js";
-export { runReindex, type ReindexOptions, type ReindexResult, } from "./governance/reindex.js";
+export { runReindex,type ReindexOptions,type ReindexResult,} from "./governance/reindex.js";
 export * from "./governance/stale-work.js";
 export * from "./governance/storage-integrity.js";
 export * from "./governance/status-role-diagnostics.js";
 export * from "./governance/workspace-position.js";
 export * from "./governance/workflow-policy.js";
-export { runUpgrade, type UpgradeCliResult, type UpgradeCommandOptions, type UpgradeCommandRunner, type UpgradeCommandRunnerResult, type UpgradePackageResult, type UpgradeResult, } from "./governance/upgrade.js";
+export { runUpgrade,type UpgradeCliResult,type UpgradeCommandOptions,type UpgradeCommandRunner,type UpgradeCommandRunnerResult,type UpgradePackageResult,type UpgradeResult,} from "./governance/upgrade.js";
 export * from "./governance/validate.js";
 export * from "./governance/closure-timestamps.js";
 export * from "./governance/linked-file-report.js";

package/dist/sdk/graph/adapter.d.ts

@@ -1,106 +1,106 @@
-import { RelationshipGraph, RelationshipKindRegistry, type RelationshipEdge, type RelationshipKindDefinition } from "../relationships.js";
+import { RelationshipGraph,RelationshipKindRegistry,type RelationshipEdge,type RelationshipKindDefinition } from "../relationships.js";
 /** Current portable relationship-graph snapshot format. */
 export declare const RELATIONSHIP_GRAPH_SNAPSHOT_VERSION = 1;
 /** Immutable, content-addressed graph state exchanged with an adapter. */
 export interface RelationshipGraphSnapshot {
 /** Snapshot format version. */
-version: number;
+version:number;
 /** SHA-256 digest of nodes, edges, and relationship semantics. */
-fingerprint: string;
+fingerprint:string;
 /** ISO timestamp describing when this portable projection was created. */
-created_at: string;
+created_at:string;
 /** Deterministically ordered node identifiers. */
-nodes: readonly string[];
+nodes:readonly string[];
 /** Deterministically ordered normalized relationship edges. */
-edges: readonly RelationshipEdge[];
+edges:readonly RelationshipEdge[];
 /** Complete relationship ontology required to interpret the edges. */
-kinds: readonly RelationshipKindDefinition[];
+kinds:readonly RelationshipKindDefinition[];
 }
 /** Common adapter operation context. */
 export interface RelationshipGraphAdapterContext {
 /** Adapter-owned workspace key; it need not be a filesystem path. */
-workspace: string;
+workspace:string;
 /** Cooperative cancellation signal. */
-signal?: AbortSignal;
+signal?:AbortSignal;
 }
 /** Compare-and-swap replacement context for one complete snapshot. */
 export interface RelationshipGraphAdapterReplaceContext extends RelationshipGraphAdapterContext {
 /** Validated snapshot that becomes the complete visible graph state. */
-snapshot: RelationshipGraphSnapshot;
+snapshot:RelationshipGraphSnapshot;
 /** Expected prior fingerprint; null requires an empty workspace. */
-expected_fingerprint?: string | null;
+expected_fingerprint?:string | null;
 }
 /** Storage-neutral graph snapshot adapter implemented by SDK packages. */
 export interface RelationshipGraphAdapter {
 /** Stable adapter identifier used in diagnostics. */
-readonly name: string;
+readonly name:string;
 /** Read the current portable snapshot, or null when absent. */
-read(context: RelationshipGraphAdapterContext): Promise<unknown | null>;
+read(context:RelationshipGraphAdapterContext):Promise<unknown | null>;
 /** Atomically replace the complete snapshot with optional CAS protection. */
-replace(context: RelationshipGraphAdapterReplaceContext): Promise<void>;
+replace(context:RelationshipGraphAdapterReplaceContext):Promise<void>;
 /** Optionally clear a workspace with the same CAS semantics. */
-clear?(context: RelationshipGraphAdapterContext & {
-expected_fingerprint?: string | null;
-}): Promise<void>;
+clear?(context:RelationshipGraphAdapterContext & {
+expected_fingerprint?:string | null;
+}):Promise<void>;
 }
 /** Validated snapshot paired with executable registry and graph views. */
 export interface LoadedRelationshipGraphSnapshot {
 /** Portable immutable snapshot. */
-snapshot: RelationshipGraphSnapshot;
+snapshot:RelationshipGraphSnapshot;
 /** Registry reconstructed from the snapshot ontology. */
-registry: RelationshipKindRegistry;
+registry:RelationshipKindRegistry;
 /** Executable graph reconstructed through the public kernel. */
-graph: RelationshipGraph;
+graph:RelationshipGraph;
 }
 /** Result of synchronizing one snapshot into an adapter. */
 export interface RelationshipGraphAdapterSyncResult {
 /** Adapter identifier. */
-adapter: string;
+adapter:string;
 /** Adapter-owned workspace key. */
-workspace: string;
+workspace:string;
 /** Whether a write was required. */
-disposition: "current" | "written";
+disposition:"current" | "written";
 /** New canonical snapshot fingerprint. */
-fingerprint: string;
+fingerprint:string;
 /** Prior fingerprint when a snapshot existed. */
-previous_fingerprint?: string;
+previous_fingerprint?:string;
 /** Portable node count. */
-node_count: number;
+node_count:number;
 /** Portable edge count. */
-edge_count: number;
+edge_count:number;
 }
 /** Build an immutable portable snapshot from a validated graph and registry. */
-export declare function createRelationshipGraphSnapshot(graph: RelationshipGraph, registry: RelationshipKindRegistry, options?: {
-createdAt?: string;
-}): RelationshipGraphSnapshot;
+export declare function createRelationshipGraphSnapshot(graph:RelationshipGraph,registry:RelationshipKindRegistry,options?:{
+createdAt?:string;
+}):RelationshipGraphSnapshot;
 /** Decode and fully validate a portable graph snapshot. */
-export declare function parseRelationshipGraphSnapshot(value: unknown): LoadedRelationshipGraphSnapshot;
+export declare function parseRelationshipGraphSnapshot(value:unknown):LoadedRelationshipGraphSnapshot;
 /** Read and validate one adapter workspace. */
-export declare function loadRelationshipGraphAdapter(adapter: RelationshipGraphAdapter, context: RelationshipGraphAdapterContext): Promise<LoadedRelationshipGraphSnapshot | null>;
+export declare function loadRelationshipGraphAdapter(adapter:RelationshipGraphAdapter,context:RelationshipGraphAdapterContext):Promise<LoadedRelationshipGraphSnapshot | null>;
 /**
  * Synchronize a complete graph snapshot with compare-and-swap protection and
  * verify the adapter's visible read after replacement.
  */
-export declare function syncRelationshipGraphAdapter(adapter: RelationshipGraphAdapter, context: RelationshipGraphAdapterContext & {
-snapshot: RelationshipGraphSnapshot;
-}): Promise<RelationshipGraphAdapterSyncResult>;
+export declare function syncRelationshipGraphAdapter(adapter:RelationshipGraphAdapter,context:RelationshipGraphAdapterContext & {
+snapshot:RelationshipGraphSnapshot;
+}):Promise<RelationshipGraphAdapterSyncResult>;
 /** Merge portable snapshots while rejecting semantic kind collisions. */
-export declare function federateRelationshipGraphSnapshots(values: readonly unknown[], options?: {
-createdAt?: string;
-}): RelationshipGraphSnapshot;
+export declare function federateRelationshipGraphSnapshots(values:readonly unknown[],options?:{
+createdAt?:string;
+}):RelationshipGraphSnapshot;
 /** In-memory reference adapter with atomic CAS behavior for tests and packages. */
 export declare class MemoryRelationshipGraphAdapter implements RelationshipGraphAdapter {
 #private;
 /** Stable adapter identifier used in diagnostics and conformance reports. */
-readonly name: string;
+readonly name:string;
 /** Create a reference adapter with a stable diagnostic name. */
-constructor(name?: string);
+constructor(name?:string);
 /** Read an isolated clone of the current workspace snapshot. */
-read(context: RelationshipGraphAdapterContext): Promise<RelationshipGraphSnapshot | null>;
+read(context:RelationshipGraphAdapterContext):Promise<RelationshipGraphSnapshot | null>;
 /** Atomically replace one workspace after enforcing its expected fingerprint. */
-replace(context: RelationshipGraphAdapterReplaceContext): Promise<void>;
+replace(context:RelationshipGraphAdapterReplaceContext):Promise<void>;
 /** Clear one workspace after enforcing its expected fingerprint. */
-clear(context: RelationshipGraphAdapterContext & {
-expected_fingerprint?: string | null;
-}): Promise<void>;
+clear(context:RelationshipGraphAdapterContext & {
+expected_fingerprint?:string | null;
+}):Promise<void>;
 }

package/dist/sdk/graph/analytics.d.ts

@@ -9,82 +9,82 @@
  * and reports exact cost metadata so agents can budget follow-up reads
  * without re-scanning the workspace.
  */
-import { RelationshipGraph, type RelationshipEdge, type RelationshipKindDefinition, type RelationshipQueryResult, type RelationshipTraversalDirection } from "../relationships.js";
+import { RelationshipGraph,type RelationshipEdge,type RelationshipKindDefinition,type RelationshipQueryResult,type RelationshipTraversalDirection } from "../relationships.js";
 /** One detected relationship community. */
 export interface RelationshipCommunity {
 /** Lexicographically smallest member id, naming the community. */
-representative: string;
+representative:string;
 /** Total member count. */
-size: number;
+size:number;
 /** Sorted member node ids. */
-members: string[];
+members:string[];
 }
 /** Bounded community-detection controls. */
 export interface GraphCommunityOptions {
 /** Registered relationship kinds whose edges define adjacency. */
-kinds?: readonly string[];
+kinds?:readonly string[];
 /** Maximum label-propagation sweeps before reporting non-convergence; defaults to 16. */
-maxIterations?: number;
+maxIterations?:number;
 /** Minimum member count for a reported community; defaults to 2. */
-minSize?: number;
+minSize?:number;
 /** Abort signal checked once per sweep. */
-signal?: AbortSignal;
+signal?:AbortSignal;
 }
 /** Deterministic label-propagation community analysis. */
 export interface RelationshipCommunityAnalysis {
 /** Detected communities, largest first and by representative within equal size. */
-communities: RelationshipCommunity[];
+communities:RelationshipCommunity[];
 /** Label-propagation sweeps executed. */
-iterations: number;
+iterations:number;
 /** Whether labels stabilized before the iteration bound stopped the sweep. */
-converged: boolean;
+converged:boolean;
 }
 /** One stored edge implied by a longer same-family witness path. */
 export interface RedundantRelationshipEdge {
 /** The stored redundant edge in its original spelling. */
-edge: RelationshipEdge;
+edge:RelationshipEdge;
 /** Semantic-orientation witness node path proving the implication, endpoints inclusive. */
-witness: string[];
+witness:string[];
 }
 /** Bounded redundancy-scan controls. */
 export interface GraphRedundancyOptions {
 /** Directed ordering or hierarchy kinds to scan; defaults to every eligible registered kind. */
-kinds?: readonly string[];
+kinds?:readonly string[];
 /** Maximum witness-path depth searched per edge; defaults to 8. */
-maxDepth?: number;
+maxDepth?:number;
 /** Maximum reported redundant edges. */
-limit?: number;
+limit?:number;
 /** Abort signal checked once per scanned edge. */
-signal?: AbortSignal;
+signal?:AbortSignal;
 }
 /** One reachable node with its immediate dominator and gating weight. */
 export interface RelationshipDominatorRow {
 /** Reachable node id. */
-id: string;
+id:string;
 /** Immediate dominator appearing on every root-to-node path. */
-idom: string;
+idom:string;
 /** Nodes strictly dominated by this node — its dominator-subtree size minus itself. */
-dominatedCount: number;
+dominatedCount:number;
 }
 /** Bounded dominator-analysis controls. */
 export interface GraphDominatorOptions {
 /** Registered relationship kinds whose edges define reachability. */
-kinds?: readonly string[];
+kinds?:readonly string[];
 /** Traversal direction relative to each visited node; defaults to "outgoing". */
-direction?: RelationshipTraversalDirection;
+direction?:RelationshipTraversalDirection;
 /** Maximum reachability depth from the root as a non-negative integer. */
-maxDepth?: number;
+maxDepth?:number;
 /** Abort signal checked once per processed node. */
-signal?: AbortSignal;
+signal?:AbortSignal;
 }
 /** Dominator-tree analysis of one node's reachable subgraph. */
 export interface RelationshipDominatorAnalysis {
 /** Analyzed root id. */
-root: string;
+root:string;
 /** Reachable node count including the root. */
-reachableCount: number;
+reachableCount:number;
 /** Non-root reachable rows sorted by gating weight, then id. */
-rows: RelationshipDominatorRow[];
+rows:RelationshipDominatorRow[];
 }
 /**
  * Invoke `visit` once per canonical-kind-matched edge, skipping self-loops.
@@ -94,7 +94,7 @@ rows: RelationshipDominatorRow[];
  * directed and undirected families. This is the single edge-selection primitive
  * shared by community, centrality, cut-structure, and degree builders.
  */
-export declare function forEachMatchedRelationshipEdge(graph: RelationshipGraph, kinds: readonly string[] | undefined, visit: (edge: RelationshipEdge, definition: RelationshipKindDefinition) => void): void;
+export declare function forEachMatchedRelationshipEdge(graph:RelationshipGraph,kinds:readonly string[] | undefined,visit:(edge:RelationshipEdge,definition:RelationshipKindDefinition) => void):void;
 /**
  * Detect communities with deterministic asynchronous label propagation: nodes
  * are swept in sorted order, each adopting the most frequent label among its
@@ -103,15 +103,15 @@ export declare function forEachMatchedRelationshipEdge(graph: RelationshipGraph,
  * participating edge connects both endpoints symmetrically and parallel edges
  * weight their neighbor. `meta.truncated` reports non-convergence.
  */
-export declare function detectRelationshipCommunities(graph: RelationshipGraph, options?: GraphCommunityOptions): RelationshipQueryResult<RelationshipCommunityAnalysis>;
+export declare function detectRelationshipCommunities(graph:RelationshipGraph,options?:GraphCommunityOptions):RelationshipQueryResult<RelationshipCommunityAnalysis>;
 /** Decide whether a kind carries transitive semantics eligible for redundancy and duplicate analysis. */
-export declare function isTransitiveKind(definition: RelationshipKindDefinition): boolean;
+export declare function isTransitiveKind(definition:RelationshipKindDefinition):boolean;
 /** Family grouping key joining a directed kind with its inverse spelling. */
-export declare function transitiveFamilyKey(definition: RelationshipKindDefinition): string;
+export declare function transitiveFamilyKey(definition:RelationshipKindDefinition):string;
 /** Orient one transitive edge into its semantic forward direction. */
-export declare function orientTransitiveEdge(edge: RelationshipEdge, definition: RelationshipKindDefinition): {
-from: string;
-to: string;
+export declare function orientTransitiveEdge(edge:RelationshipEdge,definition:RelationshipKindDefinition):{
+from:string;
+to:string;
 };
 /**
  * Find stored edges implied by a longer path of the same semantic family —
@@ -121,7 +121,7 @@ to: string;
  * search is breadth-first, shortest and lexicographic first, bounded by
  * `maxDepth` per edge; `meta.truncated` reports only the `limit` bound.
  */
-export declare function findRedundantRelationshipEdges(graph: RelationshipGraph, options?: GraphRedundancyOptions): RelationshipQueryResult<RedundantRelationshipEdge[]>;
+export declare function findRedundantRelationshipEdges(graph:RelationshipGraph,options?:GraphRedundancyOptions):RelationshipQueryResult<RedundantRelationshipEdge[]>;
 /**
  * Compute immediate dominators and gating weights over one node's reachable
  * subgraph using the Cooper–Harvey–Kennedy fixed-point. A node dominates the
@@ -130,4 +130,4 @@ export declare function findRedundantRelationshipEdges(graph: RelationshipGraph,
  * root's blast radius. Rows sort by gating weight, then id; `meta.truncated`
  * reports when the `maxDepth` bound excluded reachable nodes.
  */
-export declare function computeRelationshipDominators(graph: RelationshipGraph, root: string, options?: GraphDominatorOptions): RelationshipQueryResult<RelationshipDominatorAnalysis>;
+export declare function computeRelationshipDominators(graph:RelationshipGraph,root:string,options?:GraphDominatorOptions):RelationshipQueryResult<RelationshipDominatorAnalysis>;

package/dist/sdk/graph/assembly.d.ts

@@ -9,53 +9,53 @@
  * endpoints as placeholder nodes so bounded traversals can explain absent work
  * instead of silently dropping it.
  */
-import type { Dependency, ItemStatus } from "../../types/index.js";
-import { RelationshipGraph, type RelationshipKindRegistry } from "../relationships.js";
+import type { Dependency,ItemStatus } from "../../types/index.js";
+import { RelationshipGraph,type RelationshipKindRegistry } from "../relationships.js";
 import { type HierarchyIntegrityAnalysis } from "./hierarchy-integrity.js";
 export { resolveWorkspaceRelationshipKindRegistry } from "./workspace-relationship-kind-registry.js";
 /** Minimal item shape inspected by dependency-reference governance. */
 export interface DependencyReferenceHolder {
 /** Stable item identifier. */
-id: string;
+id:string;
 /** Lifecycle status used to separate actionable work from historical debt. */
-status: ItemStatus;
+status:ItemStatus;
 /** Optional hierarchy parent reference. */
-parent?: string;
+parent?:string;
 /** Optional legacy scalar blocker reference. */
-blocked_by?: string;
+blocked_by?:string;
 /** Structured dependency edges. */
-dependencies?: Dependency[];
+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;
+holder_id:string;
 /** Missing referenced item id or legacy sentinel. */
-target_id: string;
+target_id:string;
 /** Relationship field or dependency kind. */
-kind: string;
+kind:string;
 /** Storage surface that owns the reference and determines its remediation. */
-source: DependencyReferenceSource;
+source:DependencyReferenceSource;
 /** Current lifecycle status of the holder. */
-holder_status: ItemStatus;
+holder_status:ItemStatus;
 /** Whether the holder is terminal and therefore historical, non-actionable debt. */
-legacy_terminal: boolean;
+legacy_terminal:boolean;
 /** Whether the target is the pre-structured-dependency `no-active-blocker` sentinel. */
-no_active_blocker_sentinel: boolean;
+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[];
+active:DanglingDependencyReference[];
 /** Missing references held only by terminal items; retained as informational history debt. */
-legacy_terminal: DanglingDependencyReference[];
+legacy_terminal:DanglingDependencyReference[];
 /** Legacy sentinel rows across active and terminal holders, called out separately from typo-like ids. */
-no_active_blocker_sentinels: DanglingDependencyReference[];
+no_active_blocker_sentinels:DanglingDependencyReference[];
 }
 /** Normalize a graph target while removing the historical no-blocker marker. */
-export declare function normalizeDependencyGraphTarget(target: unknown): string | undefined;
+export declare function normalizeDependencyGraphTarget(target:unknown):string | undefined;
 /**
  * Resolve the default workspace relationship-kind registry: the built-in kinds
  * merged with every active extension-contributed relationship-kind
@@ -66,30 +66,30 @@ export declare function normalizeDependencyGraphTarget(target: unknown): string
 /** One raw stored dependency row duplicated verbatim on a single holder. */
 export interface DuplicateDependencyRow {
 /** Item that stores the duplicated row. */
-holder_id: string;
+holder_id:string;
 /** Referenced target id in its first stored spelling. */
-target_id: string;
+target_id:string;
 /** Stored relationship kind shared by every duplicate occurrence. */
-kind: string;
+kind:string;
 /** Total stored occurrences of the identical row (always >= 2). */
-occurrences: number;
+occurrences:number;
 /** Current lifecycle status of the holder. */
-holder_status: ItemStatus;
+holder_status:ItemStatus;
 /** Whether the holder is terminal and the duplication is historical debt. */
-legacy_terminal: boolean;
+legacy_terminal:boolean;
 }
 /** One holder whose scalar blocker and structured ordering row assert opposite precedence. */
 export interface OrderingStorageContradiction {
 /** Item storing both contradictory representations. */
-holder_id: string;
+holder_id:string;
 /** Target named by both the scalar blocker and structured dependency row. */
-target_id: string;
+target_id:string;
 /** Structured ordering kind that places the holder before the target. */
-dependency_kind: string;
+dependency_kind:string;
 /** Current lifecycle status of the holder. */
-holder_status: ItemStatus;
+holder_status:ItemStatus;
 /** Whether the holder is terminal and the contradiction is historical debt. */
-legacy_terminal: boolean;
+legacy_terminal:boolean;
 }
 /**
  * Collect raw stored dependency rows whose exact identity — holder, kind, and
@@ -98,7 +98,7 @@ legacy_terminal: boolean;
  * every projection built on it cannot see them; this pre-assembly scan is the
  * only surface that reports the storage-layer defect.
  */
-export declare function collectDuplicateDependencyRows(items: readonly DependencyReferenceHolder[], isTerminal?: (status: ItemStatus) => boolean): DuplicateDependencyRow[];
+export declare function collectDuplicateDependencyRows(items:readonly DependencyReferenceHolder[],isTerminal?:(status:ItemStatus) => boolean):DuplicateDependencyRow[];
 /**
  * Collect storage rows where `blocked_by: target` places the target before the
  * holder while a same-target structured ordering dependency places the holder
@@ -106,7 +106,7 @@ export declare function collectDuplicateDependencyRows(items: readonly Dependenc
  * after graph assembly, so this pre-assembly evidence identifies the exact row
  * to remove instead of reporting only strongly connected component members.
  */
-export declare function collectOrderingStorageContradictions(items: readonly DependencyReferenceHolder[], isTerminal?: (status: ItemStatus) => boolean, registry?: RelationshipKindRegistry): OrderingStorageContradiction[];
+export declare function collectOrderingStorageContradictions(items:readonly DependencyReferenceHolder[],isTerminal?:(status:ItemStatus) => boolean,registry?:RelationshipKindRegistry):OrderingStorageContradiction[];
 /**
  * Classify missing hierarchy and dependency targets without mutating their holders.
  *
@@ -114,52 +114,52 @@ export declare function collectOrderingStorageContradictions(items: readonly Dep
  * 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;
+export declare function collectDanglingDependencyReferences(items:readonly DependencyReferenceHolder[],isTerminal?:(status:ItemStatus) => boolean):DanglingDependencyReferenceSummary;
 /** Return unique real missing targets while excluding the legacy no-blocker sentinel. */
-export declare function collectMissingDependencyTargetIds(dangling: DanglingDependencyReferenceSummary): string[];
+export declare function collectMissingDependencyTargetIds(dangling:DanglingDependencyReferenceSummary):string[];
 /** Return unique explicitly external dependency targets in deterministic order. */
-export declare function collectExternalDependencyTargetIds(items: readonly DependencyReferenceHolder[]): string[];
+export declare function collectExternalDependencyTargetIds(items:readonly DependencyReferenceHolder[]):string[];
 /** Item shape accepted by workspace relationship-graph assembly. */
 export interface WorkspaceRelationshipItem extends DependencyReferenceHolder {
 /** Human-readable title projected into per-node details. */
-title: string;
+title:string;
 /** Optional item type powering per-type coverage profiles and policies. */
-type?: string;
+type?:string;
 }
 /** Compact node projection paired with the assembled graph. */
 export interface WorkspaceRelationshipNodeDetails {
 /** Stable node identifier. */
-id: string;
+id:string;
 /** Human-readable node title, or a `[missing]` marker for absent endpoints. */
-title: string;
+title:string;
 /** Lifecycle status, or the `missing` marker status for absent endpoints. */
-status: string;
+status:string;
 /** Item type when the source item declared one; absent on missing placeholders. */
-type?: string;
+type?:string;
 }
 /** Assembled workspace relationship graph with governance side-products. */
 export interface WorkspaceRelationshipAssembly {
 /** Deterministic relationship graph including missing placeholder nodes. */
-graph: RelationshipGraph;
+graph:RelationshipGraph;
 /** Per-node compact details covering real and missing nodes. */
-details: WorkspaceRelationshipNodeDetails[];
+details:WorkspaceRelationshipNodeDetails[];
 /** Lowercased identifiers of materialized missing endpoints. */
-missingIdSet: Set<string>;
+missingIdSet:Set<string>;
 /** Dangling-reference classification computed during assembly. */
-dangling: DanglingDependencyReferenceSummary;
+dangling:DanglingDependencyReferenceSummary;
 /** Raw same-identity duplicated dependency rows found before graph dedup. */
-duplicateRows: DuplicateDependencyRow[];
+duplicateRows:DuplicateDependencyRow[];
 /** Scalar-versus-structured ordering contradictions found before graph normalization. */
-orderingContradictions?: OrderingStorageContradiction[];
+orderingContradictions?:OrderingStorageContradiction[];
 /** Raw legacy alias rows grouped by accepted spelling before graph canonicalization. */
-legacyAliasCounts: Record<string, number>;
+legacyAliasCounts:Record<string,number>;
 /** Shared hierarchy analysis retained across ordinary object spread copies. */
-hierarchyIntegrity?: HierarchyIntegrityAnalysis;
+hierarchyIntegrity?:HierarchyIntegrityAnalysis;
 }
 /** Read the hierarchy analysis paired with an assembly created by this module. */
-export declare function getWorkspaceHierarchyIntegrity(assembly: WorkspaceRelationshipAssembly): HierarchyIntegrityAnalysis | undefined;
+export declare function getWorkspaceHierarchyIntegrity(assembly:WorkspaceRelationshipAssembly):HierarchyIntegrityAnalysis | undefined;
 /** Count raw dependency rows that use a registered compatibility alias instead of its canonical kind. */
-export declare function collectLegacyDependencyAliasCounts(items: readonly DependencyReferenceHolder[], registry?: RelationshipKindRegistry): Record<string, number>;
+export declare function collectLegacyDependencyAliasCounts(items:readonly DependencyReferenceHolder[],registry?:RelationshipKindRegistry):Record<string,number>;
 /**
  * Build the shared workspace relationship graph including missing placeholder
  * nodes. One assembly serves every bounded query in an invocation — dependency
@@ -167,4 +167,4 @@ export declare function collectLegacyDependencyAliasCounts(items: readonly Depen
  * audits — so the full-workspace normalization cost is paid once instead of
  * once per query surface.
  */
-export declare function assembleWorkspaceRelationshipGraph(items: readonly WorkspaceRelationshipItem[], isTerminal?: (status: ItemStatus) => boolean, registry?: RelationshipKindRegistry): WorkspaceRelationshipAssembly;
+export declare function assembleWorkspaceRelationshipGraph(items:readonly WorkspaceRelationshipItem[],isTerminal?:(status:ItemStatus) => boolean,registry?:RelationshipKindRegistry):WorkspaceRelationshipAssembly;

package/dist/sdk/graph/cache.d.ts

@@ -1,16 +1,16 @@
 import type { ItemStatus } from "../../types/index.js";
 import { type RelationshipKindRegistry } from "../relationships.js";
-import type { WorkspaceRelationshipAssembly, WorkspaceRelationshipItem } from "./assembly.js";
+import type { WorkspaceRelationshipAssembly,WorkspaceRelationshipItem } from "./assembly.js";
 /** Cache observability attached to graph result envelopes. */
 export interface GraphCacheMetadata {
 /** Truncated workspace graph fingerprint identifying the snapshot answered from. */
-fingerprint: string;
+fingerprint:string;
 /** Whether the workspace assembly was reused from cache. */
-assembly: "hit" | "miss";
+assembly:"hit" | "miss";
 /** Whether the full query result was reused from cache. */
-result: "hit" | "miss";
+result:"hit" | "miss";
 /** Durable cross-process index disposition: answered from it, missed it, or persistence disabled for this workspace. Absent on surfaces that never consult the durable index. */
-durable?: "hit" | "miss" | "off";
+durable?:"hit" | "miss" | "off";
 }
 /**
  * Compute the deterministic workspace graph fingerprint for one item snapshot.
@@ -19,15 +19,15 @@ durable?: "hit" | "miss" | "off";
  * folded in so schema changes to lifecycle semantics invalidate cached
  * assemblies even when raw statuses are unchanged.
  */
-export declare function computeWorkspaceGraphFingerprint(items: readonly WorkspaceRelationshipItem[], isTerminal?: (status: ItemStatus) => boolean, registry?: RelationshipKindRegistry): string;
+export declare function computeWorkspaceGraphFingerprint(items:readonly WorkspaceRelationshipItem[],isTerminal?:(status:ItemStatus) => boolean,registry?:RelationshipKindRegistry):string;
 /** One resolved cache lookup bound to a workspace snapshot. */
 export interface WorkspaceGraphCacheLookup {
 /** The (possibly reused) workspace assembly. */
-assembly: WorkspaceRelationshipAssembly;
+assembly:WorkspaceRelationshipAssembly;
 /** Whether the assembly came from cache instead of being rebuilt. */
-assemblyReused: boolean;
+assemblyReused:boolean;
 /** Full fingerprint of the snapshot this lookup is bound to. */
-fingerprint: string;
+fingerprint:string;
 /**
      * Memoize one deterministic query result under this snapshot. On a miss the
      * freshly computed value is returned as-is while an independent clone is
@@ -35,9 +35,9 @@ fingerprint: string;
      * returns a fresh clone of the stored entry. Callers must not rely on the
      * miss and hit paths returning the same object identity.
      */
-memoize<T>(queryKey: string, compute: () => T): {
-value: T;
-reused: boolean;
+memoize<T>(queryKey:string,compute:() => T):{
+value:T;
+reused:boolean;
 };
 }
 /**
@@ -50,20 +50,20 @@ reused: boolean;
 export declare class WorkspaceGraphCache {
 #private;
 /** Create a cache, optionally bounding workspaces and memoized results. */
-constructor(options?: {
-maxResultsPerWorkspace?: number;
-maxWorkspaces?: number;
+constructor(options?:{
+maxResultsPerWorkspace?:number;
+maxWorkspaces?:number;
 });
 /**
      * 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: string, fingerprint: string, build: () => WorkspaceRelationshipAssembly): WorkspaceGraphCacheLookup;
+lookup(key:string,fingerprint:string,build:() => WorkspaceRelationshipAssembly):WorkspaceGraphCacheLookup;
 /** Drop every cached workspace entry and memoized result. */
-clear(): void;
+clear():void;
 }
 /** Return the process-wide shared workspace graph cache. */
-export declare function workspaceGraphCache(): WorkspaceGraphCache;
+export declare function workspaceGraphCache():WorkspaceGraphCache;
 /** Reset the process-wide shared workspace graph cache (tests and long-lived hosts). */
-export declare function resetWorkspaceGraphCache(): void;
+export declare function resetWorkspaceGraphCache():void;

package/dist/sdk/graph/cardinality-integrity.d.ts

@@ -3,11 +3,11 @@ import type { RelationshipKindRegistry } from "../relationships.js";
 /** Minimal immutable item projection needed to compare relationship cardinality. */
 export interface RelationshipCardinalityItem {
 /** Canonical workspace item identity. */
-id: string;
+id:string;
 /** Stored relationship rows, including their canonical kind and endpoint. */
-dependencies?: readonly Pick<Dependency, "id" | "kind">[];
+dependencies?:readonly Pick<Dependency,"id" | "kind">[];
 }
 /** Share the workspace integrity lock for every kind that constrains edge multiplicity. */
-export declare function relationshipKindNeedsIntegrityLock(kind: string, registry: RelationshipKindRegistry): boolean;
+export declare function relationshipKindNeedsIntegrityLock(kind:string,registry:RelationshipKindRegistry):boolean;
 /** Reject newly introduced non-hierarchy cardinality debt while allowing unchanged debt and repairs. */
-export declare function assertNonHierarchyCardinalityMutationAllowed(before: readonly RelationshipCardinalityItem[], after: readonly RelationshipCardinalityItem[], registry?: RelationshipKindRegistry): void;
+export declare function assertNonHierarchyCardinalityMutationAllowed(before:readonly RelationshipCardinalityItem[],after:readonly RelationshipCardinalityItem[],registry?:RelationshipKindRegistry):void;