@unbrained/pm-cli 2026.10.13 → 2026.10.15

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

@@ -12,10 +12,10 @@
  * carries a deterministic bounded sample, and proposes a safe next action so
  * agents can plan remediation without re-deriving context.
  */
-import type { RelationshipEdge, RelationshipOutcomeTraversal } from "../relationships.js";
-import type { OrderingStorageContradiction, WorkspaceRelationshipAssembly } from "./assembly.js";
+import type { RelationshipEdge,RelationshipOutcomeTraversal } from "../relationships.js";
+import type { OrderingStorageContradiction,WorkspaceRelationshipAssembly } from "./assembly.js";
 import { type RelationshipLifecycleCoverage } from "./lifecycle-coverage.js";
-export type { RelationshipPopulationCoverage, RelationshipLifecycleCoverage } from "./lifecycle-coverage.js";
+export type { RelationshipPopulationCoverage,RelationshipLifecycleCoverage } from "./lifecycle-coverage.js";
 import { type RelationshipAuditFindingCode } from "./governance-contracts.js";
 export type { RelationshipAuditFindingCode } from "./governance-contracts.js";
 /** Severity ladder shared by every relationship audit finding. */
@@ -23,126 +23,126 @@ export type RelationshipAuditSeverity = "error" | "warning" | "info";
 /** One policy-aware relationship audit finding with bounded evidence. */
 export interface RelationshipAuditFinding {
 /** Machine-readable finding family identifier. */
-code: RelationshipAuditFindingCode;
+code:RelationshipAuditFindingCode;
 /** Severity of the violated policy. */
-severity: RelationshipAuditSeverity;
+severity:RelationshipAuditSeverity;
 /** Policy statement this finding violates. */
-policy: string;
+policy:string;
 /** Human-readable summary including the affected count. */
-message: string;
+message:string;
 /** Total number of affected subjects, independent of sample bounding. */
-count: number;
+count:number;
 /** Deterministic bounded sample of affected subjects. */
-sample: string[];
+sample:string[];
 /** Optional exact evidence that explains why the sampled subjects were selected. */
-evidence?: string[];
+evidence?:string[];
 /** Whether {@link sample} was truncated by the configured sample bound. */
-sample_truncated: boolean;
+sample_truncated:boolean;
 /** Safe machine-actionable next step; audits never invent or auto-apply edges. */
-remediation: string;
+remediation:string;
 }
 /** Per-item-type connectivity coverage inside a coverage profile. */
 export interface RelationshipCoverageTypeProfile {
 /** Active nodes declaring this item type. */
-active: number;
+active:number;
 /** Active nodes of this type with no incident edges. */
-isolated: number;
+isolated:number;
 /** Active nodes of this type with at most one incident edge, isolates included. */
-degree_leq_one: number;
+degree_leq_one:number;
 }
 /** Aggregate structural coverage metrics for one assembled workspace graph. */
 export interface RelationshipCoverageProfile extends RelationshipLifecycleCoverage {
 /** Structural ordering acyclicity across all lifecycle states, independent of finding severity. */
-ordering_acyclic: boolean;
+ordering_acyclic:boolean;
 /** Whether every ordering cycle is confined to terminal items. */
-active_ordering_acyclic: boolean;
+active_ordering_acyclic:boolean;
 /** Total indexed nodes including materialized missing placeholders. */
-nodes: number;
+nodes:number;
 /** Tracker-recorded nodes, excluding synthesized missing and external placeholders. */
-recorded_nodes?: number;
+recorded_nodes?:number;
 /** Total deduplicated indexed edges. */
-edges: number;
+edges:number;
 /** Edges that remain after excluding redundant and contradictory storage rows. */
-informative_edges?: number;
+informative_edges?:number;
 /** Stored edges implied by a bounded longer path in the same semantic family. */
-redundant_edges?: number;
+redundant_edges?:number;
 /** Structured ordering edges that contradict a same-target scalar blocker. */
-ordering_contradiction_edges?: number;
+ordering_contradiction_edges?:number;
 /** Counting convention used by edges and edges_by_kind. */
-edge_basis: "deduplicated_directed";
+edge_basis:"deduplicated_directed";
 /** Deterministic per-kind edge counts. */
-edges_by_kind: Record<string, number>;
+edges_by_kind:Record<string,number>;
 /** Per-kind share of all deduplicated directed edges. */
-edge_share_by_kind: Record<string, number>;
+edge_share_by_kind:Record<string,number>;
 /** Edges carrying discovery, provenance, incident, or verification semantics. */
-semantic_edges: number;
+semantic_edges:number;
 /** Share of all edges carrying discovery, provenance, incident, or verification semantics. */
-semantic_edge_share: number;
+semantic_edge_share:number;
 /** Nodes whose lifecycle status is active (non-terminal, non-missing). */
-active_nodes: number;
+active_nodes:number;
 /** Materialized placeholder nodes for referenced-but-absent items. */
-missing_nodes: number;
+missing_nodes:number;
 /** Active nodes with no incident edges at all. */
-isolated_active_nodes: number;
+isolated_active_nodes:number;
 /** Active nodes with at most one incident edge, isolates included. */
-degree_leq_one_active_nodes: number;
+degree_leq_one_active_nodes:number;
 /** Deterministic per-type connectivity coverage; untyped nodes bucket under `(untyped)`. */
-coverage_by_type: Record<string, RelationshipCoverageTypeProfile>;
+coverage_by_type:Record<string,RelationshipCoverageTypeProfile>;
 /** Undirected cut vertices whose removal increases the component count. */
-articulation_points: number;
+articulation_points:number;
 /** Undirected cut edges whose removal disconnects their endpoints. */
-bridge_edges: number;
+bridge_edges:number;
 /** Milestone nodes whose title explicitly declares an outcome. */
-outcome_nodes: number;
+outcome_nodes:number;
 /** Declared edge kinds and directions admitted by typed outcome reachability. */
-outcome_reachability_basis: Record<RelationshipOutcomeTraversal, string>;
+outcome_reachability_basis:Record<RelationshipOutcomeTraversal,string>;
 /** Active non-outcome nodes with a path admitted by outcome_reachability_basis. */
-active_outcome_reachable_nodes: number;
+active_outcome_reachable_nodes:number;
 /** Active non-outcome nodes without a path admitted by outcome_reachability_basis. */
-active_outcome_unreachable_nodes: number;
+active_outcome_unreachable_nodes:number;
 /** Active typed-outcome reachability expressed as integer basis points. */
-active_outcome_reachability_basis_points: number;
+active_outcome_reachability_basis_points:number;
 /** Terminal non-placeholder, non-outcome nodes included in the all-status census. */
-terminal_nodes: number;
+terminal_nodes:number;
 /** Terminal non-outcome nodes with a path admitted by outcome_reachability_basis. */
-terminal_outcome_reachable_nodes: number;
+terminal_outcome_reachable_nodes:number;
 /** Terminal non-outcome nodes without a path admitted by outcome_reachability_basis. */
-terminal_outcome_unreachable_nodes: number;
+terminal_outcome_unreachable_nodes:number;
 /** Terminal typed-outcome reachability expressed as integer basis points. */
-terminal_outcome_reachability_basis_points: number;
+terminal_outcome_reachability_basis_points:number;
 /** All active and terminal non-outcome nodes with a typed path to an outcome. */
-outcome_reachable_nodes: number;
+outcome_reachable_nodes:number;
 /** All active and terminal non-outcome nodes without a typed path to an outcome. */
-outcome_unreachable_nodes: number;
+outcome_unreachable_nodes:number;
 /** All-status typed-outcome reachability expressed as integer basis points. */
-outcome_reachability_basis_points: number;
+outcome_reachability_basis_points:number;
 /** Affected-subject census containing every known finding code, including zero populations. */
-finding_subjects_by_code: Record<RelationshipAuditFindingCode, number>;
+finding_subjects_by_code:Record<RelationshipAuditFindingCode,number>;
 }
 /** Tuning and policy inputs accepted by the relationship audit. */
 export interface RelationshipAuditOptions {
 /** Terminal-lifecycle predicate; defaults to the built-in closed/canceled statuses. */
-isTerminal?: (status: string) => boolean;
+isTerminal?:(status:string) => boolean;
 /** Blocked-lifecycle predicate for stale-block detection; defaults to `status === "blocked"`. */
-isBlocked?: (status: string) => boolean;
+isBlocked?:(status:string) => boolean;
 /** Node identifiers that are explicitly valid isolates (roots, archives, scratch work). */
-exemptIsolates?: readonly string[];
+exemptIsolates?:readonly string[];
 /** Item types whose active nodes are policy-valid isolates or sparse nodes (case-insensitive); they stay in the coverage profile but raise no coverage finding. */
-isolateExemptTypes?: readonly string[];
+isolateExemptTypes?:readonly string[];
 /** Maximum sample entries retained per finding; defaults to 25. */
-maxSampleSize?: number;
+maxSampleSize?:number;
 /** Abort signal checked between finding families. */
-signal?: AbortSignal;
+signal?:AbortSignal;
 }
 /** Complete deterministic result of one relationship-graph audit. */
 export interface RelationshipAuditReport {
 /** Findings ordered by severity, then code, then first sample subject. */
-findings: RelationshipAuditFinding[];
+findings:RelationshipAuditFinding[];
 /** Structural coverage metrics computed during the audit. */
-profile: RelationshipCoverageProfile;
+profile:RelationshipCoverageProfile;
 }
 /** Return whether a relationship kind carries provenance or verification context. */
-export declare function isSemanticContextKind(kind: string): boolean;
+export declare function isSemanticContextKind(kind:string):boolean;
 /**
  * Enumerate strongly connected components with more than one member (or a
  * self-loop) over an ordering-only successor digraph using an iterative Tarjan
@@ -151,20 +151,20 @@ export declare function isSemanticContextKind(kind: string): boolean;
  * of cycle analysis by policy. Exported so incremental consumers (mutation
  * advisories) share one cycle semantics with the workspace audit.
  */
-export declare function collectOrderingCycles(successors: Map<string, string[]>): string[][];
+export declare function collectOrderingCycles(successors:Map<string,string[]>):string[][];
 /** Format the exact contradictory storage pair that manufactures an ordering cycle. */
-export declare function formatOrderingStorageContradiction(contradiction: Pick<OrderingStorageContradiction, "holder_id" | "target_id" | "dependency_kind">): string;
+export declare function formatOrderingStorageContradiction(contradiction:Pick<OrderingStorageContradiction,"holder_id" | "target_id" | "dependency_kind">):string;
 /** One duplicate-edge group in semantic orientation with its stored spellings. */
 export interface DuplicateRelationshipEdgeGroup {
 /** Semantic tail node shared by every stored spelling. */
-from: string;
+from:string;
 /** Semantic head node shared by every stored spelling. */
-to: string;
+to:string;
 /** Stored parallel edges sorted by kind. */
-edges: RelationshipEdge[];
+edges:RelationshipEdge[];
 }
 /** Format one duplicate-edge group as a compact deterministic evidence string. */
-export declare function formatDuplicateEdgeGroup(group: DuplicateRelationshipEdgeGroup): string;
+export declare function formatDuplicateEdgeGroup(group:DuplicateRelationshipEdgeGroup):string;
 /**
  * Collect the groups of parallel same-family stored edges over the directed
  * ordering and hierarchy families. Each family joins a kind with its inverse
@@ -174,7 +174,7 @@ export declare function formatDuplicateEdgeGroup(group: DuplicateRelationshipEdg
  * deterministic orientation order with per-group edges sorted by kind, source,
  * then target — the exact stored identities remediation planning targets.
  */
-export declare function collectDuplicateRelationshipEdgeGroups(assembly: WorkspaceRelationshipAssembly): DuplicateRelationshipEdgeGroup[];
+export declare function collectDuplicateRelationshipEdgeGroups(assembly:WorkspaceRelationshipAssembly):DuplicateRelationshipEdgeGroup[];
 /**
  * Audit one assembled workspace relationship graph against the shared
  * governance policy and return deterministic machine-readable findings plus a
@@ -185,64 +185,64 @@ export declare function collectDuplicateRelationshipEdgeGroups(assembly: Workspa
  * isolate exemptions, and cycle findings enumerate the strongly connected
  * members so callers can decide which edge to retype, remove, or waive.
  */
-export declare function auditWorkspaceRelationshipGraph(assembly: WorkspaceRelationshipAssembly, options?: RelationshipAuditOptions): RelationshipAuditReport;
+export declare function auditWorkspaceRelationshipGraph(assembly:WorkspaceRelationshipAssembly,options?:RelationshipAuditOptions):RelationshipAuditReport;
 /** One persisted point-in-time audit census used for temporal comparison. */
 export interface RelationshipAuditSnapshot {
 /** ISO timestamp the snapshot was taken at. */
-saved_at: string;
+saved_at:string;
 /** Workspace graph fingerprint of the audited item snapshot. */
-fingerprint: string;
+fingerprint:string;
 /** Affected-subject counts keyed by finding code at snapshot time. */
-affected_subjects_by_code: Record<string, number>;
+affected_subjects_by_code:Record<string,number>;
 /** Structural coverage profile at snapshot time. */
-profile: RelationshipCoverageProfile;
+profile:RelationshipCoverageProfile;
 }
 /** Signed change between two audit snapshots; zero-change keys are dropped. */
 export interface RelationshipAuditDelta {
 /** ISO timestamp of the baseline snapshot the delta is measured against. */
-baseline_saved_at: string;
+baseline_saved_at:string;
 /** Whether both snapshots audited the identical workspace fingerprint. */
-same_snapshot: boolean;
+same_snapshot:boolean;
 /** Signed affected-subject deltas keyed by finding code. */
-affected_subjects_by_code: Record<string, number>;
+affected_subjects_by_code:Record<string,number>;
 /** Signed structural profile deltas. */
-profile: {
+profile:{
 /** Whether both snapshots measured lifecycle census fields. */
-lifecycle_comparable?: boolean;
+lifecycle_comparable?:boolean;
 /** Signed population deltas, absent for legacy baselines lacking this census. */
-coverage_by_lifecycle?: RelationshipLifecycleCoverage["coverage_by_lifecycle"];
+coverage_by_lifecycle?:RelationshipLifecycleCoverage["coverage_by_lifecycle"];
 /** Signed raw-status population deltas, absent for legacy baselines. */
-coverage_by_status?: RelationshipLifecycleCoverage["coverage_by_status"];
+coverage_by_status?:RelationshipLifecycleCoverage["coverage_by_status"];
 /** Node-count change including missing placeholders. */
-nodes: number;
+nodes:number;
 /** Tracker-recorded node-count change excluding synthesized placeholders. */
-recorded_nodes?: number;
+recorded_nodes?:number;
 /** Deduplicated edge-count change. */
-edges: number;
+edges:number;
 /** Informative edge-count change after non-information deductions. */
-informative_edges?: number;
+informative_edges?:number;
 /** Redundant edge-count change. */
-redundant_edges?: number;
+redundant_edges?:number;
 /** Ordering contradiction edge-count change. */
-ordering_contradiction_edges?: number;
+ordering_contradiction_edges?:number;
 /** Active-node-count change. */
-active_nodes: number;
+active_nodes:number;
 /** Missing-placeholder-count change. */
-missing_nodes: number;
+missing_nodes:number;
 /** Isolated-active-node-count change. */
-isolated_active_nodes: number;
+isolated_active_nodes:number;
 /** Degree-at-most-one active-node-count change. */
-degree_leq_one_active_nodes: number;
+degree_leq_one_active_nodes:number;
 /** Signed per-kind edge-count deltas; unchanged kinds are dropped. */
-edges_by_kind: Record<string, number>;
+edges_by_kind:Record<string,number>;
 /** Signed per-kind edge-share deltas; unchanged kinds are dropped. */
-edge_share_by_kind: Record<string, number>;
+edge_share_by_kind:Record<string,number>;
 /** Change in semantic-context edge count. */
-semantic_edges: number;
+semantic_edges:number;
 /** Change in semantic-context edge share. */
-semantic_edge_share: number;
+semantic_edge_share:number;
 /** Signed per-type coverage deltas; unchanged types are dropped. */
-coverage_by_type: Record<string, RelationshipCoverageTypeProfile>;
+coverage_by_type:Record<string,RelationshipCoverageTypeProfile>;
 };
 }
 /**
@@ -251,4 +251,4 @@ coverage_by_type: Record<string, RelationshipCoverageTypeProfile>;
  * change-since-baseline audit reporting: agents track census drift across
  * sessions without re-deriving or storing full finding collections.
  */
-export declare function diffRelationshipAuditSnapshots(baseline: RelationshipAuditSnapshot, current: RelationshipAuditSnapshot): RelationshipAuditDelta;
+export declare function diffRelationshipAuditSnapshots(baseline:RelationshipAuditSnapshot,current:RelationshipAuditSnapshot):RelationshipAuditDelta;

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

@@ -1,94 +1,94 @@
-import type { Dependency, ItemStatus } from "../../types/index.js";
+import type { Dependency,ItemStatus } from "../../types/index.js";
 import type { RelationshipKindRegistry } from "../relationships.js";
 /** Storage surface from which one normalized hierarchy relation originated. */
 export type HierarchyRelationSource = "scalar_parent" | "dependency";
 /** Minimal workspace item shape required by hierarchy-integrity analysis. */
 export interface HierarchyIntegrityItem {
 /** Stable item identifier. */
-id: string;
+id:string;
 /** Lifecycle status used to classify historical-only defects. */
-status: ItemStatus;
+status:ItemStatus;
 /** Optional scalar structural parent. */
-parent?: string;
+parent?:string;
 /** Structured relationship rows that may carry hierarchy semantics. */
-dependencies?: Dependency[];
+dependencies?:Dependency[];
 }
 /** One canonical parent-to-child relation with exact stored-row provenance. */
 export interface HierarchyRelation {
 /** Canonical structural parent identifier. */
-parent_id: string;
+parent_id:string;
 /** Canonical structural child identifier. */
-child_id: string;
+child_id:string;
 /** Storage surface that asserted the relation. */
-source: HierarchyRelationSource;
+source:HierarchyRelationSource;
 /** Canonical relationship kind, or `parent` for the scalar field. */
-kind: string;
+kind:string;
 /** Item document that stores the relation. */
-holder_id: string;
+holder_id:string;
 /** Referenced endpoint for dependency-backed relations. */
-target_id?: string;
+target_id?:string;
 /** Registry cardinality at the child endpoint of this relation. */
-child_cardinality: "one" | "many";
+child_cardinality:"one" | "many";
 }
 /** One strongly connected hierarchy component. */
 export interface HierarchyCycle {
 /** Deterministically sorted item identifiers in the cycle. */
-item_ids: string[];
+item_ids:string[];
 /** Whether every member is in a terminal lifecycle state. */
-legacy_terminal: boolean;
+legacy_terminal:boolean;
 }
 /** One child assigned to more than one logical parent. */
 export interface HierarchyCardinalityViolation {
 /** Child whose parent cardinality was exceeded. */
-child_id: string;
+child_id:string;
 /** Deterministically sorted unique parent identifiers. */
-parent_ids: string[];
+parent_ids:string[];
 /** Whether the child and every asserted parent are terminal. */
-legacy_terminal: boolean;
+legacy_terminal:boolean;
 }
 /** One scalar parent that disagrees with dependency-backed hierarchy evidence. */
 export interface HierarchyParentDivergence {
 /** Child whose hierarchy storage surfaces disagree. */
-child_id: string;
+child_id:string;
 /** Parent declared by the scalar metadata field. */
-scalar_parent_id: string;
+scalar_parent_id:string;
 /** Different dependency-backed parent identifiers. */
-dependency_parent_ids: string[];
+dependency_parent_ids:string[];
 /** Whether the child and every asserted parent are terminal. */
-legacy_terminal: boolean;
+legacy_terminal:boolean;
 }
 /** Complete deterministic hierarchy-integrity projection for a workspace. */
 export interface HierarchyIntegrityAnalysis {
 /** Normalized evidence rows retained for exact diagnostics and repair. */
-relations: HierarchyRelation[];
+relations:HierarchyRelation[];
 /** Cyclic structural components. */
-cycles: HierarchyCycle[];
+cycles:HierarchyCycle[];
 /** Logical one-parent cardinality violations. */
-cardinality_violations: HierarchyCardinalityViolation[];
+cardinality_violations:HierarchyCardinalityViolation[];
 /** Scalar and dependency-backed parent disagreements. */
-divergences: HierarchyParentDivergence[];
+divergences:HierarchyParentDivergence[];
 }
 /** Deterministic adjacency indexes derived from normalized hierarchy evidence. */
 export interface HierarchyRelationIndexes {
 /** Unique logical parents keyed by child id. */
-parents_by_child: ReadonlyMap<string, readonly string[]>;
+parents_by_child:ReadonlyMap<string,readonly string[]>;
 /** Unique logical children keyed by parent id. */
-children_by_parent: ReadonlyMap<string, readonly string[]>;
+children_by_parent:ReadonlyMap<string,readonly string[]>;
 }
 /** Collect normalized hierarchy evidence without running defect analysis. */
-export declare function collectHierarchyRelations(items: readonly HierarchyIntegrityItem[], registry?: RelationshipKindRegistry): HierarchyRelation[];
+export declare function collectHierarchyRelations(items:readonly HierarchyIntegrityItem[],registry?:RelationshipKindRegistry):HierarchyRelation[];
 /**
  * Analyze all runtime-recognized hierarchy spellings as canonical parent-child
  * relations. Unknown, malformed, and dangling rows are ignored here because
  * dedicated graph-integrity checks own those diagnostics.
  */
-export declare function analyzeHierarchyIntegrity(items: readonly HierarchyIntegrityItem[], isTerminal?: (status: ItemStatus) => boolean, registry?: RelationshipKindRegistry): HierarchyIntegrityAnalysis;
+export declare function analyzeHierarchyIntegrity(items:readonly HierarchyIntegrityItem[],isTerminal?:(status:ItemStatus) => boolean,registry?:RelationshipKindRegistry):HierarchyIntegrityAnalysis;
 /** Render exact hierarchy evidence without losing its storage orientation. */
-export declare function formatHierarchyRelation(relation: HierarchyRelation): string;
+export declare function formatHierarchyRelation(relation:HierarchyRelation):string;
 /** Index normalized hierarchy evidence for list, tree, and rollup consumers. */
-export declare function indexHierarchyRelations(relations: readonly HierarchyRelation[]): HierarchyRelationIndexes;
+export declare function indexHierarchyRelations(relations:readonly HierarchyRelation[]):HierarchyRelationIndexes;
 /**
  * Reject a mutation only when it introduces a new hierarchy defect involving
  * the changed item. Existing debt remains repairable without a global bypass.
  */
-export declare function assertHierarchyMutationAllowed(beforeItems: readonly HierarchyIntegrityItem[], afterItems: readonly HierarchyIntegrityItem[], changedItemId: string, isTerminal?: (status: ItemStatus) => boolean, registry?: RelationshipKindRegistry): void;
+export declare function assertHierarchyMutationAllowed(beforeItems:readonly HierarchyIntegrityItem[],afterItems:readonly HierarchyIntegrityItem[],changedItemId:string,isTerminal?:(status:ItemStatus) => boolean,registry?:RelationshipKindRegistry):void;

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

@@ -8,19 +8,19 @@
  * `sdk/relationships` and is safe for CLI, MCP, extension, and non-PM callers.
  */
 export * from "./query-contracts.js";
-export { computeRelationshipDominators, detectRelationshipCommunities, findRedundantRelationshipEdges, forEachMatchedRelationshipEdge, type GraphCommunityOptions, type GraphDominatorOptions, type GraphRedundancyOptions, type RedundantRelationshipEdge, type RelationshipCommunity, type RelationshipCommunityAnalysis, type RelationshipDominatorAnalysis, type RelationshipDominatorRow, } from "./analytics.js";
-export { computeRelationshipCentrality, findRelationshipCutStructure, type GraphCentralityOptions, type GraphCutStructureOptions, type RelationshipBridge, type RelationshipCentralityAnalysis, type RelationshipCentralityRow, type RelationshipCutStructure, } from "./centrality.js";
-export { createRelationshipGraphSnapshot, federateRelationshipGraphSnapshots, loadRelationshipGraphAdapter, MemoryRelationshipGraphAdapter, parseRelationshipGraphSnapshot, RELATIONSHIP_GRAPH_SNAPSHOT_VERSION, syncRelationshipGraphAdapter, type LoadedRelationshipGraphSnapshot, type RelationshipGraphAdapter, type RelationshipGraphAdapterContext, type RelationshipGraphAdapterReplaceContext, type RelationshipGraphAdapterSyncResult, type RelationshipGraphSnapshot, } from "./adapter.js";
-export { assertMemoryRelationshipGraphAdapterConformance, assertRelationshipGraphAdapterConformance, createRelationshipGraphScaleFixture, type RelationshipGraphAdapterConformanceCase, type RelationshipGraphAdapterConformanceReport, type RelationshipGraphScaleFixture, type RelationshipGraphScaleFixtureOptions, type RelationshipGraphScaleTopology, } from "./conformance.js";
-export { analyzeRelationshipSchedule, type GraphScheduleOptions, type RelationshipScheduleAnalysis, type RelationshipScheduleRow, } from "./scheduling.js";
-export { deriveRelationshipDeadlines, type DeadlineScheduleItem, type DeadlineScheduleOptions, type DeadlineScheduleRow, type DeadlineScheduleResidual, type DeadlineOvercommitment, type DeadlineScheduleResult, } from "./deadline-scheduling.js";
-export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectDuplicateDependencyRows, collectMissingDependencyTargetIds, collectOrderingStorageContradictions, normalizeDependencyGraphTarget, resolveWorkspaceRelationshipKindRegistry, type DanglingDependencyReference, type DanglingDependencyReferenceSummary, type DependencyReferenceHolder, type DependencyReferenceSource, type DuplicateDependencyRow, type OrderingStorageContradiction, type WorkspaceRelationshipAssembly, type WorkspaceRelationshipItem, type WorkspaceRelationshipNodeDetails, } from "./assembly.js";
-export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, collectOrderingCycles, diffRelationshipAuditSnapshots, formatDuplicateEdgeGroup, formatOrderingStorageContradiction, type DuplicateRelationshipEdgeGroup, type RelationshipAuditDelta, type RelationshipAuditFinding, type RelationshipAuditFindingCode, type RelationshipAuditOptions, type RelationshipAuditReport, type RelationshipAuditSeverity, type RelationshipAuditSnapshot, type RelationshipCoverageProfile, type RelationshipCoverageTypeProfile, type RelationshipPopulationCoverage, type RelationshipLifecycleCoverage, } from "./governance.js";
-export { analyzeHierarchyIntegrity, assertHierarchyMutationAllowed, collectHierarchyRelations, formatHierarchyRelation, indexHierarchyRelations, type HierarchyCardinalityViolation, type HierarchyCycle, type HierarchyIntegrityAnalysis, type HierarchyIntegrityItem, type HierarchyParentDivergence, type HierarchyRelation, type HierarchyRelationIndexes, type HierarchyRelationSource, } from "./hierarchy-integrity.js";
-export { clearDurableGraphCache, durableGraphCachePath, durableGraphCacheStatus, GRAPH_DURABLE_CACHE_MIN_ITEMS, GRAPH_DURABLE_CACHE_VERSION, graphAuditBaselinePath, loadGraphAuditBaseline, openDurableGraphCache, persistDurableGraphResult, saveGraphAuditBaseline, shouldPersistDurableGraphCache, type DurableGraphCacheEnvelope, type DurableGraphCacheStatus, type DurableGraphCacheView, } from "./durable-cache.js";
-export { enumerateRelationshipPaths, hierarchyAncestors, hierarchyDescendants, orderingPredecessors, orderingSuccessors, type GraphPathOptions, type GraphTraversalOptions, type RelationshipPath, } from "./traversal.js";
-export { computeWorkspaceGraphFingerprint, resetWorkspaceGraphCache, workspaceGraphCache, WorkspaceGraphCache, type GraphCacheMetadata, type WorkspaceGraphCacheLookup, } from "./cache.js";
-export { planRelationshipRemediation, type RelationshipRemediationCode, type RelationshipRemediationConfidence, type RelationshipRemediationOperation, type RelationshipRemediationPlan, type RelationshipRemediationPlanOptions, type RelationshipRemediationStep, } from "./remediation.js";
+export { computeRelationshipDominators,detectRelationshipCommunities,findRedundantRelationshipEdges,forEachMatchedRelationshipEdge,type GraphCommunityOptions,type GraphDominatorOptions,type GraphRedundancyOptions,type RedundantRelationshipEdge,type RelationshipCommunity,type RelationshipCommunityAnalysis,type RelationshipDominatorAnalysis,type RelationshipDominatorRow,} from "./analytics.js";
+export { computeRelationshipCentrality,findRelationshipCutStructure,type GraphCentralityOptions,type GraphCutStructureOptions,type RelationshipBridge,type RelationshipCentralityAnalysis,type RelationshipCentralityRow,type RelationshipCutStructure,} from "./centrality.js";
+export { createRelationshipGraphSnapshot,federateRelationshipGraphSnapshots,loadRelationshipGraphAdapter,MemoryRelationshipGraphAdapter,parseRelationshipGraphSnapshot,RELATIONSHIP_GRAPH_SNAPSHOT_VERSION,syncRelationshipGraphAdapter,type LoadedRelationshipGraphSnapshot,type RelationshipGraphAdapter,type RelationshipGraphAdapterContext,type RelationshipGraphAdapterReplaceContext,type RelationshipGraphAdapterSyncResult,type RelationshipGraphSnapshot,} from "./adapter.js";
+export { assertMemoryRelationshipGraphAdapterConformance,assertRelationshipGraphAdapterConformance,createRelationshipGraphScaleFixture,type RelationshipGraphAdapterConformanceCase,type RelationshipGraphAdapterConformanceReport,type RelationshipGraphScaleFixture,type RelationshipGraphScaleFixtureOptions,type RelationshipGraphScaleTopology,} from "./conformance.js";
+export { analyzeRelationshipSchedule,type GraphScheduleOptions,type RelationshipScheduleAnalysis,type RelationshipScheduleRow,} from "./scheduling.js";
+export { deriveRelationshipDeadlines,type DeadlineScheduleItem,type DeadlineScheduleOptions,type DeadlineScheduleRow,type DeadlineScheduleResidual,type DeadlineOvercommitment,type DeadlineScheduleResult,} from "./deadline-scheduling.js";
+export { assembleWorkspaceRelationshipGraph,collectDanglingDependencyReferences,collectDuplicateDependencyRows,collectMissingDependencyTargetIds,collectOrderingStorageContradictions,normalizeDependencyGraphTarget,resolveWorkspaceRelationshipKindRegistry,type DanglingDependencyReference,type DanglingDependencyReferenceSummary,type DependencyReferenceHolder,type DependencyReferenceSource,type DuplicateDependencyRow,type OrderingStorageContradiction,type WorkspaceRelationshipAssembly,type WorkspaceRelationshipItem,type WorkspaceRelationshipNodeDetails,} from "./assembly.js";
+export { auditWorkspaceRelationshipGraph,collectDuplicateRelationshipEdgeGroups,collectOrderingCycles,diffRelationshipAuditSnapshots,formatDuplicateEdgeGroup,formatOrderingStorageContradiction,type DuplicateRelationshipEdgeGroup,type RelationshipAuditDelta,type RelationshipAuditFinding,type RelationshipAuditFindingCode,type RelationshipAuditOptions,type RelationshipAuditReport,type RelationshipAuditSeverity,type RelationshipAuditSnapshot,type RelationshipCoverageProfile,type RelationshipCoverageTypeProfile,type RelationshipPopulationCoverage,type RelationshipLifecycleCoverage,} from "./governance.js";
+export { analyzeHierarchyIntegrity,assertHierarchyMutationAllowed,collectHierarchyRelations,formatHierarchyRelation,indexHierarchyRelations,type HierarchyCardinalityViolation,type HierarchyCycle,type HierarchyIntegrityAnalysis,type HierarchyIntegrityItem,type HierarchyParentDivergence,type HierarchyRelation,type HierarchyRelationIndexes,type HierarchyRelationSource,} from "./hierarchy-integrity.js";
+export { clearDurableGraphCache,durableGraphCachePath,durableGraphCacheStatus,GRAPH_DURABLE_CACHE_MIN_ITEMS,GRAPH_DURABLE_CACHE_VERSION,graphAuditBaselinePath,loadGraphAuditBaseline,openDurableGraphCache,persistDurableGraphResult,saveGraphAuditBaseline,shouldPersistDurableGraphCache,type DurableGraphCacheEnvelope,type DurableGraphCacheStatus,type DurableGraphCacheView,} from "./durable-cache.js";
+export { enumerateRelationshipPaths,hierarchyAncestors,hierarchyDescendants,orderingPredecessors,orderingSuccessors,type GraphPathOptions,type GraphTraversalOptions,type RelationshipPath,} from "./traversal.js";
+export { computeWorkspaceGraphFingerprint,resetWorkspaceGraphCache,workspaceGraphCache,WorkspaceGraphCache,type GraphCacheMetadata,type WorkspaceGraphCacheLookup,} from "./cache.js";
+export { planRelationshipRemediation,type RelationshipRemediationCode,type RelationshipRemediationConfidence,type RelationshipRemediationOperation,type RelationshipRemediationPlan,type RelationshipRemediationPlanOptions,type RelationshipRemediationStep,} from "./remediation.js";
 export { collectNewOrderingCycleWarnings } from "./mutation-advisory.js";
-export { assertNonHierarchyCardinalityMutationAllowed, type RelationshipCardinalityItem } from "./cardinality-integrity.js";
-export { GRAPH_SUBCOMMAND_VALUES, parseGraphSubcommand, runGraph, type GraphAnalyzeResult, type GraphArticulationResult, type GraphAuditResult, type GraphAuditSummaryResult, type GraphBridgeRow, type GraphCentralityResult, type GraphCentralityRow, type GraphCommandOptions, type GraphCommunitiesResult, type GraphCommunityRow, type GraphDominatorRow, type GraphDominatorsResult, type GraphExecutionSummary, type GraphImpactResult, type GraphImpactRow, type GraphHierarchySummary, type GraphIndexResult, type GraphKnowledgeSummary, type GraphPathRow, type GraphPathsResult, type GraphPlanResult, type GraphQueryCost, type GraphRedundancyResult, type GraphRedundancyRow, type GraphResult, type GraphScheduleRow, type GraphSlackResult, type GraphSubcommand, type GraphTraversalResult, } from "./run.js";
+export { assertNonHierarchyCardinalityMutationAllowed,type RelationshipCardinalityItem } from "./cardinality-integrity.js";
+export { GRAPH_SUBCOMMAND_VALUES,parseGraphSubcommand,runGraph,type GraphAnalyzeResult,type GraphArticulationResult,type GraphAuditResult,type GraphAuditSummaryResult,type GraphBridgeRow,type GraphCentralityResult,type GraphCentralityRow,type GraphCommandOptions,type GraphCommunitiesResult,type GraphCommunityRow,type GraphDominatorRow,type GraphDominatorsResult,type GraphExecutionSummary,type GraphImpactResult,type GraphImpactRow,type GraphHierarchySummary,type GraphIndexResult,type GraphKnowledgeSummary,type GraphPathRow,type GraphPathsResult,type GraphPlanResult,type GraphQueryCost,type GraphRedundancyResult,type GraphRedundancyRow,type GraphResult,type GraphScheduleRow,type GraphSlackResult,type GraphSubcommand,type GraphTraversalResult,} from "./run.js";

package/dist/sdk/graph/lifecycle-coverage.d.ts

@@ -3,30 +3,30 @@ import type { WorkspaceRelationshipAssembly } from "./assembly.js";
 /** Connectivity counts over an explicitly named recorded-node population. */
 export interface RelationshipPopulationCoverage {
 /** Recorded items in the population, including outcome anchors. */
-nodes: number;
+nodes:number;
 /** Items with no incident relationship. */
-isolated: number;
+isolated:number;
 /** Items with zero or one incident relationship. */
-degree_leq_one: number;
+degree_leq_one:number;
 /** Items with at least one incident provenance or verification edge. */
-semantic_nodes: number;
+semantic_nodes:number;
 /** Items without incident provenance or verification edges. */
-without_semantic_edges: number;
+without_semantic_edges:number;
 /** Incident directed-edge degree distribution, keyed by exact degree. */
-degree_histogram: Record<string, number>;
+degree_histogram:Record<string,number>;
 }
 /** Named lifecycle slices and raw-status slices share the same counting convention. */
 export interface RelationshipLifecycleCoverage {
 /** Missing and external placeholders are excluded from every population. */
-coverage_by_lifecycle: Record<"all" | "active" | "terminal", RelationshipPopulationCoverage>;
+coverage_by_lifecycle:Record<"all" | "active" | "terminal",RelationshipPopulationCoverage>;
 /** Raw schema statuses are retained, including custom terminal statuses. */
-coverage_by_status: Record<string, RelationshipPopulationCoverage>;
+coverage_by_status:Record<string,RelationshipPopulationCoverage>;
 }
 /** Count each recorded item once per slice; edge incidence uses the assembled graph's deduplicated directed basis. */
-export declare function profileRelationshipLifecycles(assembly: WorkspaceRelationshipAssembly, isTerminal: (status: string) => boolean, isSemantic: (kind: string) => boolean, signal?: AbortSignal): RelationshipLifecycleCoverage;
+export declare function profileRelationshipLifecycles(assembly:WorkspaceRelationshipAssembly,isTerminal:(status:string) => boolean,isSemantic:(kind:string) => boolean,signal?:AbortSignal):RelationshipLifecycleCoverage;
 /** Accept legacy absence, but reject partial or malformed new lifecycle census fields. */
-export declare function validLifecycleSnapshot(profile: Record<string, unknown>): boolean;
+export declare function validLifecycleSnapshot(profile:Record<string,unknown>):boolean;
 /** Compare measured lifecycle censuses; legacy baselines remain explicitly incomparable. */
-export declare function diffLifecycleCoverage(before: Partial<RelationshipLifecycleCoverage>, after: Partial<RelationshipLifecycleCoverage>): Partial<RelationshipLifecycleCoverage> & {
-lifecycle_comparable: boolean;
+export declare function diffLifecycleCoverage(before:Partial<RelationshipLifecycleCoverage>,after:Partial<RelationshipLifecycleCoverage>):Partial<RelationshipLifecycleCoverage> & {
+lifecycle_comparable:boolean;
 };

package/dist/sdk/graph/mutation-advisory.d.ts

@@ -14,18 +14,18 @@ import type { RelationshipKindRegistry } from "../relationships.js";
 /** Lightweight ordering digraph over one immutable item snapshot. */
 interface OrderingDigraph {
 /** Sorted successor adjacency oriented predecessor -> successor. */
-successors: Map<string, string[]>;
+successors:Map<string,string[]>;
 /** Sorted predecessor adjacency, the reverse orientation of successors. */
-predecessors: Map<string, string[]>;
+predecessors:Map<string,string[]>;
 /** Canonical original-case ids keyed by their lowercase spelling. */
-canonicalIds: Map<string, string>;
+canonicalIds:Map<string,string>;
 }
 /**
  * Build the ordering-only digraph for one item snapshot without assembling a
  * full relationship graph: one linear pass over the legacy scalar blocker and
  * structured dependency rows of every item.
  */
-declare function buildOrderingDigraph(items: readonly ItemMetadata[], registry: RelationshipKindRegistry): OrderingDigraph;
+declare function buildOrderingDigraph(items:readonly ItemMetadata[],registry:RelationshipKindRegistry):OrderingDigraph;
 /**
  * Collect the changed item's weakly connected ordering component: every node
  * reachable through ordering edges in either orientation. Cycle enumeration
@@ -33,19 +33,19 @@ declare function buildOrderingDigraph(items: readonly ItemMetadata[], registry:
  * item, because a strongly connected component is always contained in a
  * weakly connected one.
  */
-declare function collectWeakComponent(digraph: OrderingDigraph, start: string): Set<string>;
+declare function collectWeakComponent(digraph:OrderingDigraph,start:string):Set<string>;
 /** Restrict a successor adjacency to edges whose endpoints are both members. */
-declare function induceSuccessors(digraph: OrderingDigraph, members: ReadonlySet<string>): Map<string, string[]>;
-declare function findCyclePath(adjacency: ReadonlyMap<string, readonly string[]>, component: readonly string[], changedItemId: string): string[];
-declare function findPathBackToStart(adjacency: ReadonlyMap<string, readonly string[]>, members: ReadonlySet<string>, start: string, first: string): string[] | undefined;
+declare function induceSuccessors(digraph:OrderingDigraph,members:ReadonlySet<string>):Map<string,string[]>;
+declare function findCyclePath(adjacency:ReadonlyMap<string,readonly string[]>,component:readonly string[],changedItemId:string):string[];
+declare function findPathBackToStart(adjacency:ReadonlyMap<string,readonly string[]>,members:ReadonlySet<string>,start:string,first:string):string[] | undefined;
 /** Return actionable warnings only for ordering cycles created by the later snapshot and containing the changed item. */
-export declare function collectNewOrderingCycleWarnings(beforeItems: readonly ItemMetadata[], afterItems: readonly ItemMetadata[], changedItemId: string): string[];
+export declare function collectNewOrderingCycleWarnings(beforeItems:readonly ItemMetadata[],afterItems:readonly ItemMetadata[],changedItemId:string):string[];
 /** White-box graph-path helpers for exhaustive SDK primitive verification. */
-export declare const mutationAdvisoryTestOnly: {
-buildOrderingDigraph: typeof buildOrderingDigraph;
-collectWeakComponent: typeof collectWeakComponent;
-induceSuccessors: typeof induceSuccessors;
-findCyclePath: typeof findCyclePath;
-findPathBackToStart: typeof findPathBackToStart;
+export declare const mutationAdvisoryTestOnly:{
+buildOrderingDigraph:typeof buildOrderingDigraph;
+collectWeakComponent:typeof collectWeakComponent;
+induceSuccessors:typeof induceSuccessors;
+findCyclePath:typeof findCyclePath;
+findPathBackToStart:typeof findPathBackToStart;
 };
 export {};

package/dist/sdk/graph/query-contracts.d.ts

@@ -4,15 +4,15 @@
  * Row limits bound observations, not the topology used to compute analytics.
  */
 /** Immutable observation ceilings shared by query execution and contract discovery. */
-export declare const GRAPH_QUERY_DEFAULTS: Readonly<{
+export declare const GRAPH_QUERY_DEFAULTS:Readonly<{
 /** Maximum emitted rows in each traversal or analytics collection. */
-rows: 10;
+rows:10;
 /** Maximum paths emitted by path enumeration. */
-paths: 5;
+paths:5;
 /** Maximum evidence examples per governance finding. */
-samples: 10;
+samples:10;
 /** Default depth of path enumeration; other traversals have no depth ceiling. */
-path_depth: 8;
+path_depth:8;
 /** Maximum partial paths expanded before enumeration reports truncation. */
-visited_paths: 10000;
+visited_paths:10000;
 }>;