@unbrained/pm-cli 2026.10.14 → 2026.10.15

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

@@ -1,491 +1,491 @@
 import type { GlobalOptions } from "../../core/shared/command-types.js";
 import { type DeadlineScheduleResult } from "./deadline-scheduling.js";
 import { type GraphCacheMetadata } from "./cache.js";
-import { type RelationshipAuditDelta, type RelationshipAuditReport } from "./governance.js";
+import { type RelationshipAuditDelta,type RelationshipAuditReport } from "./governance.js";
 import type { RelationshipPopulationCoverage } from "./lifecycle-coverage.js";
 import { type RelationshipRemediationStep } from "./remediation.js";
-import { GRAPH_SUBCOMMAND_VALUES, type GraphSubcommand } from "../cli-contracts/enum-contracts.js";
+import { GRAPH_SUBCOMMAND_VALUES,type GraphSubcommand } from "../cli-contracts/enum-contracts.js";
 import { type OutputProjectionDeclaration } from "../output-projection.js";
-export { GRAPH_SUBCOMMAND_VALUES, type GraphSubcommand };
+export { GRAPH_SUBCOMMAND_VALUES,type GraphSubcommand };
 /** Documents the graph command options payload exchanged by command, SDK, and package integrations. */
 export interface GraphCommandOptions {
 /** Restricts traversal to registered relationship kinds (repeatable or comma-separated). */
-kind?: string | string[];
+kind?:string | string[];
 /** Maximum traversal depth as a non-negative integer. */
-maxDepth?: string | number;
+maxDepth?:string | number;
 /** Maximum returned rows per bounded collection. */
-limit?: string | number;
+limit?:string | number;
 /** Resume a traversal after this previously returned node id. */
-after?: string;
+after?:string;
 /** Edge orientation for paths and impact queries (outgoing, incoming, or both). */
-direction?: string;
+direction?:string;
 /** Maximum enumerated paths for the paths subcommand. */
-maxPaths?: string | number;
+maxPaths?:string | number;
 /** Maximum evidence sample entries per audit finding. */
-sample?: string | number;
+sample?:string | number;
 /** Item ids treated as explicitly valid isolates by the audit. */
-exemptIsolate?: string | string[];
+exemptIsolate?:string | string[];
 /** Item types whose active nodes are policy-valid isolates for the audit (repeatable or comma-separated). */
-exemptIsolateType?: string | string[];
+exemptIsolateType?:string | string[];
 /** Persist the audit census as the change-since-baseline comparison point (audit only). */
-saveBaseline?: boolean;
+saveBaseline?:boolean;
 /** Rebuild and warm the durable graph index (index only). */
-rebuild?: boolean;
+rebuild?:boolean;
 /** Delete the durable graph index (index only). */
-clear?: boolean;
+clear?:boolean;
 /** Return counts-first envelopes without row collections. */
-summary?: boolean;
+summary?:boolean;
 /** Explicitly restore the complete row projection after a summary read. */
-full?: boolean;
+full?:boolean;
 }
 /** Cost metadata attached to every graph query projection. */
 export interface GraphQueryCost {
 /** Nodes expanded while answering the query. */
-visited_nodes: number;
+visited_nodes:number;
 /** Edges inspected while answering the query. */
-inspected_edges: number;
+inspected_edges:number;
 }
 /** Result envelope for the transitive traversal subcommands. */
 export interface GraphTraversalResult {
 /** Executed graph subcommand. */
-subcommand: "ancestors" | "descendants" | "predecessors" | "successors";
+subcommand:"ancestors" | "descendants" | "predecessors" | "successors";
 /** Canonical root item id. */
-root: string;
+root:string;
 /** Total emitted node ids before summary suppression. */
-count: number;
+count:number;
 /** Whether configured bounds omitted reachable work. */
-truncated: boolean;
+truncated:boolean;
 /** Cursor resuming emission after the last returned node. */
-next_cursor?: string;
+next_cursor?:string;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Emitted node ids in deterministic breadth-first order; absent with summary. */
-ids?: string[];
+ids?:string[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One enumerated path projected with relationship kinds instead of raw edges. */
 export interface GraphPathRow {
 /** Ordered node ids from source to target inclusive. */
-nodes: string[];
+nodes:string[];
 /** Relationship kind of each traversed edge, in path order. */
-kinds: string[];
+kinds:string[];
 /** Number of edges in the path. */
-length: number;
+length:number;
 }
 /** Result envelope for the paths subcommand. */
 export interface GraphPathsResult {
 /** Executed graph subcommand. */
-subcommand: "paths";
+subcommand:"paths";
 /** Canonical source item id. */
-root: string;
+root:string;
 /** Canonical target item id. */
-target: string;
+target:string;
 /** Traversal orientation used for the enumeration. */
-direction: string;
+direction:string;
 /** Total enumerated paths before summary suppression. */
-count: number;
+count:number;
 /** Whether depth, path-count, or safety bounds stopped the search early. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Enumerated paths, shortest first; absent with summary. */
-paths?: GraphPathRow[];
+paths?:GraphPathRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One affected item row in an impact projection. */
 export interface GraphImpactRow {
 /** Affected item id. */
-id: string;
+id:string;
 /** Shortest relationship distance from the root. */
-distance: number;
+distance:number;
 /** Exact node path explaining why the item is affected. */
-path: string[];
+path:string[];
 }
 /** Result envelope for the impact subcommand. */
 export interface GraphImpactResult {
 /** Executed graph subcommand. */
-subcommand: "impact";
+subcommand:"impact";
 /** Canonical impact-origin item id. */
-root: string;
+root:string;
 /** Traversal orientation used for the blast-radius walk. */
-direction: string;
+direction:string;
 /** Total affected items before summary suppression. */
-count: number;
+count:number;
 /** Whether configured bounds omitted reachable work. */
-truncated: boolean;
+truncated:boolean;
 /** Cursor resuming after the final returned affected item. */
-next_cursor?: string;
+next_cursor?:string;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Affected item rows ordered by discovery; absent with summary. */
-affected?: GraphImpactRow[];
+affected?:GraphImpactRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** Bounded execution-graph projection inside an analyze result. */
 export interface GraphExecutionSummary {
 /** Whether the order-bearing graph is acyclic. */
-acyclic: boolean;
+acyclic:boolean;
 /** Nodes participating in the topological order. */
-ordered_node_count: number;
+ordered_node_count:number;
 /** Number of parallelizable topological layers. */
-layer_count: number;
+layer_count:number;
 /** Total items with no open prerequisites. */
-frontier_count: number;
+frontier_count:number;
 /** Bounded prerequisite-free sample; absent with summary. */
-frontier?: string[];
+frontier?:string[];
 /** Edge count of the longest execution path. */
-critical_path_length: number;
+critical_path_length:number;
 /** Longest deterministic execution path; absent with summary. */
-critical_path?: string[];
+critical_path?:string[];
 /** Total genuine ordering cycles. */
-cycle_count: number;
+cycle_count:number;
 /** Bounded ordering-cycle sample; absent with summary. */
-cycles?: string[][];
+cycles?:string[][];
 }
 /** Bounded knowledge-graph projection inside an analyze result. */
 export interface GraphKnowledgeSummary {
 /** Total weakly connected components. */
-component_count: number;
+component_count:number;
 /** Node count of the largest component. */
-largest_component_size: number;
+largest_component_size:number;
 /** Total nodes without any relationship edges. */
-orphan_count: number;
+orphan_count:number;
 /** Bounded orphan sample; absent with summary. */
-orphans?: string[];
+orphans?:string[];
 /** Bounded maximum-degree hubs; absent with summary. */
-hubs?: {
-id: string;
-degree: number;
+hubs?:{
+id:string;
+degree:number;
 }[];
 }
 /** Unified hierarchy-integrity projection inside an analyze result. */
 export interface GraphHierarchySummary {
 /** Whether the structural hierarchy is acyclic. */
-acyclic: boolean;
+acyclic:boolean;
 /** Total canonical parent-child evidence rows. */
-relation_count: number;
+relation_count:number;
 /** Total strongly connected hierarchy components. */
-cycle_count: number;
+cycle_count:number;
 /** Active hierarchy cycles that require remediation. */
-active_cycle_count?: number;
+active_cycle_count?:number;
 /** Terminal-only hierarchy cycles retained as historical debt. */
-legacy_cycle_count?: number;
+legacy_cycle_count?:number;
 /** Total children that resolve to more than one logical parent. */
-cardinality_violation_count: number;
+cardinality_violation_count:number;
 /** Active one-parent cardinality violations. */
-active_cardinality_violation_count?: number;
+active_cardinality_violation_count?:number;
 /** Terminal-only one-parent cardinality violations. */
-legacy_cardinality_violation_count?: number;
+legacy_cardinality_violation_count?:number;
 /** Total scalar/dependency parent disagreements. */
-parent_divergence_count: number;
+parent_divergence_count:number;
 /** Active scalar/dependency parent disagreements. */
-active_parent_divergence_count?: number;
+active_parent_divergence_count?:number;
 /** Terminal-only scalar/dependency parent disagreements. */
-legacy_parent_divergence_count?: number;
+legacy_parent_divergence_count?:number;
 /** Bounded hierarchy-cycle sample; absent with summary. */
-cycles?: string[][];
+cycles?:string[][];
 }
 /** Result envelope for the analyze subcommand. */
 export interface GraphAnalyzeResult {
 /** Executed graph subcommand. */
-subcommand: "analyze";
+subcommand:"analyze";
 /** Total indexed graph nodes. */
-node_count: number;
+node_count:number;
 /** Total deduplicated graph edges. */
-edge_count: number;
+edge_count:number;
 /** Counting convention used by edge_count. */
-edge_basis: "deduplicated_directed";
+edge_basis:"deduplicated_directed";
 /** Bound applied to every sample collection. */
-sample_limit: number;
+sample_limit:number;
 /** Execution-order analytics over registered ordering kinds. */
-execution: GraphExecutionSummary;
+execution:GraphExecutionSummary;
 /** Structural analytics over every stored edge. */
-knowledge: GraphKnowledgeSummary;
+knowledge:GraphKnowledgeSummary;
 /** Registry-driven structural hierarchy integrity across all storage surfaces. */
-hierarchy?: GraphHierarchySummary;
+hierarchy?:GraphHierarchySummary;
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** Result envelope for the audit subcommand. */
 export interface GraphAuditResult {
 /** Whether the row bound omitted findings; counts still describe the complete audit. */
-truncated?: boolean;
+truncated?:boolean;
 /** Executed graph subcommand. */
-subcommand: "audit";
+subcommand:"audit";
 /** Total audit findings. */
-finding_count: number;
+finding_count:number;
 /** Finding counts keyed by severity. */
-findings_by_severity: Record<string, number>;
+findings_by_severity:Record<string,number>;
 /** Finding-row counts keyed by finding code. Before 2026.7.19 this field incorrectly accumulated affected subjects; consumers of that unit must migrate to affected_subjects_by_code. */
-findings_by_code: Record<string, number>;
+findings_by_code:Record<string,number>;
 /** Affected-subject counts keyed by severity. */
-affected_subjects_by_severity: Record<string, number>;
+affected_subjects_by_severity:Record<string,number>;
 /** Affected-subject counts keyed by finding code. */
-affected_subjects_by_code: Record<string, number>;
+affected_subjects_by_code:Record<string,number>;
 /** Structural coverage metrics; the duplicated finding census is absent with summary. */
-profile: Omit<RelationshipAuditReport["profile"], "finding_subjects_by_code"> & Partial<Pick<RelationshipAuditReport["profile"], "finding_subjects_by_code">>;
+profile:Omit<RelationshipAuditReport["profile"],"finding_subjects_by_code"> & Partial<Pick<RelationshipAuditReport["profile"],"finding_subjects_by_code">>;
 /** Stored legacy relationship aliases grouped by spelling; canonical graph counts remain in profile. */
-legacy_alias_counts?: Record<string, number>;
+legacy_alias_counts?:Record<string,number>;
 /** Ordered findings with bounded evidence samples; absent with summary. */
-findings?: RelationshipAuditReport["findings"];
+findings?:RelationshipAuditReport["findings"];
 /** Signed change since the persisted census baseline; absent when no baseline exists. */
-baseline?: RelationshipAuditDelta;
+baseline?:RelationshipAuditDelta;
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** Result envelope for the durable-index maintenance subcommand. */
 export interface GraphIndexResult {
 /** Executed graph subcommand. */
-subcommand: "index";
+subcommand:"index";
 /** Maintenance action performed by this invocation. */
-action: "status" | "rebuilt" | "cleared";
+action:"status" | "rebuilt" | "cleared";
 /** Durable index disposition against the current workspace snapshot. */
-state: "fresh" | "stale" | "absent";
+state:"fresh" | "stale" | "absent";
 /** Persisted deterministic query results in the envelope. */
-entry_count: number;
+entry_count:number;
 /** Items in the current workspace snapshot. */
-item_count: number;
+item_count:number;
 /** Item threshold above which implicit persistence activates. */
-min_items_threshold: number;
+min_items_threshold:number;
 /** Whether queries on this workspace will persist results right now. */
-persist_enabled: boolean;
+persist_enabled:boolean;
 /** Truncated fingerprint of the current workspace snapshot. */
-current_fingerprint: string;
+current_fingerprint:string;
 /** ISO timestamp of the last persisted write, absent without an envelope. */
-saved_at?: string;
+saved_at?:string;
 /** Envelope size in bytes, absent without an envelope. */
-bytes?: number;
+bytes?:number;
 /** Cache observability; maintenance invocations never populate it. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One bounded community row projected by the communities subcommand. */
 export interface GraphCommunityRow {
 /** Lexicographically smallest member id, naming the community. */
-representative: string;
+representative:string;
 /** Total member count before sampling. */
-size: number;
+size:number;
 /** Bounded sorted member sample. */
-members: string[];
+members:string[];
 }
 /** Result envelope for the communities subcommand. */
 export interface GraphCommunitiesResult {
 /** Executed graph subcommand. */
-subcommand: "communities";
+subcommand:"communities";
 /** Total detected communities meeting the size floor. */
-community_count: number;
+community_count:number;
 /** Member count of the largest community. */
-largest_community_size: number;
+largest_community_size:number;
 /** Label-propagation sweeps executed. */
-iterations: number;
+iterations:number;
 /** Whether labels stabilized before the iteration bound. */
-converged: boolean;
+converged:boolean;
 /** Whether the iteration bound stopped propagation early or the sample bound omitted rows. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Bounded community rows, largest first; absent with summary. */
-communities?: GraphCommunityRow[];
+communities?:GraphCommunityRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One redundant stored edge projected with its witness path. */
 export interface GraphRedundancyRow {
 /** Stored edge source id. */
-source: string;
+source:string;
 /** Stored edge target id. */
-target: string;
+target:string;
 /** Stored relationship kind. */
-kind: string;
+kind:string;
 /** Semantic-orientation node path proving the edge is implied. */
-witness: string[];
+witness:string[];
 }
 /** Result envelope for the redundancy subcommand. */
 export interface GraphRedundancyResult {
 /** Executed graph subcommand. */
-subcommand: "redundancy";
+subcommand:"redundancy";
 /** Total redundant edges found within configured bounds. */
-redundant_count: number;
+redundant_count:number;
 /** Whether the row limit omitted further redundant edges. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Redundant edge rows in deterministic scan order; absent with summary. */
-redundant?: GraphRedundancyRow[];
+redundant?:GraphRedundancyRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One structural bottleneck row projected by the dominators subcommand. */
 export interface GraphDominatorRow {
 /** Bottleneck node id. */
-id: string;
+id:string;
 /** Immediate dominator appearing on every root-to-node path. */
-idom: string;
+idom:string;
 /** Reachable nodes strictly gated by this node. */
-dominated_count: number;
+dominated_count:number;
 }
 /** Result envelope for the dominators subcommand. */
 export interface GraphDominatorsResult {
 /** Executed graph subcommand. */
-subcommand: "dominators";
+subcommand:"dominators";
 /** Canonical analyzed root id. */
-root: string;
+root:string;
 /** Traversal orientation used for reachability. */
-direction: string;
+direction:string;
 /** Reachable node count including the root. */
-reachable_count: number;
+reachable_count:number;
 /** Total nodes gating at least one other reachable node. */
-bottleneck_count: number;
+bottleneck_count:number;
 /** Whether the depth bound cut reachability or the row limit omitted bottleneck rows. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Bounded bottleneck rows, most-gating first; absent with summary. */
-bottlenecks?: GraphDominatorRow[];
+bottlenecks?:GraphDominatorRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One scheduled task row projected by the slack subcommand. */
 export interface GraphScheduleRow {
 /** Scheduled task id. */
-id: string;
+id:string;
 /** Earliest start (longest prerequisite distance). */
-earliest_start: number;
+earliest_start:number;
 /** Latest start preserving the makespan. */
-latest_start: number;
+latest_start:number;
 /** Total float: latest start minus earliest start. */
-slack: number;
+slack:number;
 /** Whether the task lies on a critical path. */
-critical: boolean;
+critical:boolean;
 }
 /** Result envelope for the critical-path slack subcommand. */
 export interface GraphSlackResult {
 /** Fresh estimate-based deadline constraints; computed outside topology caches. */
-deadline_schedule?: {
-population: "active";
-} & Omit<DeadlineScheduleResult, "rows" | "residuals" | "overcommitted"> & Partial<Pick<DeadlineScheduleResult, "rows" | "residuals" | "overcommitted">>;
+deadline_schedule?:{
+population:"active";
+} & Omit<DeadlineScheduleResult,"rows" | "residuals" | "overcommitted"> & Partial<Pick<DeadlineScheduleResult,"rows" | "residuals" | "overcommitted">>;
 /** Executed graph subcommand. */
-subcommand: "slack";
+subcommand:"slack";
 /** Whether the order-bearing graph is acyclic. */
-acyclic: boolean;
+acyclic:boolean;
 /** Total makespan in unit task durations. */
-makespan: number;
+makespan:number;
 /** Tasks participating in the order-bearing DAG. */
-scheduled_count: number;
+scheduled_count:number;
 /** Tasks with zero slack. */
-critical_count: number;
+critical_count:number;
 /** Edge count of the longest execution path. */
-critical_path_length: number;
+critical_path_length:number;
 /** Genuine ordering cycles excluded from scheduling. */
-cycle_count: number;
+cycle_count:number;
 /** Whether the row limit omitted scheduled tasks. */
-truncated: boolean;
+truncated:boolean;
 /** Longest deterministic execution path; absent with summary. */
-critical_path?: string[];
+critical_path?:string[];
 /** Bounded scheduled rows, lowest slack first; absent with summary. */
-rows?: GraphScheduleRow[];
+rows?:GraphScheduleRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** Compact lifecycle census returned by audit summary; detailed distributions restore with --full. */
-export interface GraphAuditSummaryResult extends Omit<GraphAuditResult, "profile"> {
+export interface GraphAuditSummaryResult extends Omit<GraphAuditResult,"profile"> {
 /** Recorded population totals, structural verdicts, and lifecycle connectivity counts. */
-profile: Pick<GraphAuditResult["profile"], "nodes" | "recorded_nodes" | "edges" | "active_nodes" | "terminal_nodes" | "missing_nodes" | "ordering_acyclic" | "active_ordering_acyclic"> & {
+profile:Pick<GraphAuditResult["profile"],"nodes" | "recorded_nodes" | "edges" | "active_nodes" | "terminal_nodes" | "missing_nodes" | "ordering_acyclic" | "active_ordering_acyclic"> & {
 /** Exact lifecycle counts; degree histograms and status/type distributions require full output. */
-coverage_by_lifecycle: Record<"all" | "active" | "terminal", Omit<RelationshipPopulationCoverage, "degree_histogram">>;
+coverage_by_lifecycle:Record<"all" | "active" | "terminal",Omit<RelationshipPopulationCoverage,"degree_histogram">>;
 };
 }
 /** One node ranked by structural centrality with directed fan-in/fan-out. */
 export interface GraphCentralityRow {
 /** Node id. */
-id: string;
+id:string;
 /** Undirected unique-neighbor degree. */
-degree: number;
+degree:number;
 /** Distinct ordering predecessors that gate this node (dependency fan-in). */
-in_degree: number;
+in_degree:number;
 /** Distinct ordering successors this node gates (dependency fan-out). */
-out_degree: number;
+out_degree:number;
 /** Shortest-path betweenness centrality. */
-betweenness: number;
+betweenness:number;
 /** Wasserman–Faust closeness centrality. */
-closeness: number;
+closeness:number;
 }
 /** Result envelope for the centrality subcommand. */
 export interface GraphCentralityResult {
 /** Executed graph subcommand. */
-subcommand: "centrality";
+subcommand:"centrality";
 /** Total indexed graph nodes. */
-node_count: number;
+node_count:number;
 /** Simple undirected edge count over selected kinds. */
-edge_count: number;
+edge_count:number;
 /** Counting convention used by edge_count. */
-edge_basis: "simple_undirected";
+edge_basis:"simple_undirected";
 /** Whether the row limit omitted ranked nodes. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Bounded ranked node rows, highest betweenness first; absent with summary. */
-rows?: GraphCentralityRow[];
+rows?:GraphCentralityRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** One bridge edge projected by the articulation subcommand. */
 export interface GraphBridgeRow {
 /** Lexicographically smaller endpoint. */
-source: string;
+source:string;
 /** Lexicographically larger endpoint. */
-target: string;
+target:string;
 }
 /** Result envelope for the articulation subcommand. */
 export interface GraphArticulationResult {
 /** Executed graph subcommand. */
-subcommand: "articulation";
+subcommand:"articulation";
 /** Total articulation points (cut vertices). */
-articulation_count: number;
+articulation_count:number;
 /** Total bridge edges (cut edges). */
-bridge_count: number;
+bridge_count:number;
 /** Whether the row limit omitted articulation points or bridges. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Bounded sorted articulation-point ids; absent with summary. */
-articulation_points?: string[];
+articulation_points?:string[];
 /** Bounded sorted bridge edges; absent with summary. */
-bridges?: GraphBridgeRow[];
+bridges?:GraphBridgeRow[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** Result envelope for the dry-run remediation planning subcommand. */
 export interface GraphPlanResult {
 /** Executed graph subcommand. */
-subcommand: "plan";
+subcommand:"plan";
 /** Total derived remediation proposals before row bounding. */
-step_count: number;
+step_count:number;
 /** Proposal counts keyed by operation family. */
-steps_by_op: Record<string, number>;
+steps_by_op:Record<string,number>;
 /** Proposal counts keyed by policy code. */
-steps_by_code: Record<string, number>;
+steps_by_code:Record<string,number>;
 /** Total governance-audit findings the plan was derived from. */
-finding_count: number;
+finding_count:number;
 /** Whether sample, scan, or row bounds omitted derivable proposals. */
-truncated: boolean;
+truncated:boolean;
 /** Query cost metadata. */
-cost: GraphQueryCost;
+cost:GraphQueryCost;
 /** Bounded proposal rows in audit severity order; absent with summary. */
-steps?: RelationshipRemediationStep[];
+steps?:RelationshipRemediationStep[];
 /** Cache observability for this invocation. */
-cache?: GraphCacheMetadata;
+cache?:GraphCacheMetadata;
 }
 /** Union of every graph subcommand result envelope. */
 export type GraphResult = GraphTraversalResult | GraphPathsResult | GraphImpactResult | GraphAnalyzeResult | GraphAuditResult | GraphCommunitiesResult | GraphRedundancyResult | GraphDominatorsResult | GraphSlackResult | GraphCentralityResult | GraphArticulationResult | GraphPlanResult | GraphIndexResult;
 /** Graph result with an explicit complete-or-summary row declaration. */
 export type ProjectedGraphResult = (GraphResult | GraphAuditSummaryResult) & {
 /** Self-describing row projection used to derive a bounded omission receipt. */
-projection: OutputProjectionDeclaration;
+projection:OutputProjectionDeclaration;
 };
 /** Validate the graph subcommand and its positional-id requirements. */
-export declare function parseGraphSubcommand(raw: string, id: string | undefined, target: string | undefined): GraphSubcommand;
+export declare function parseGraphSubcommand(raw:string,id:string | undefined,target:string | undefined):GraphSubcommand;
 /** Implements run graph for the public runtime surface of this module. */
-export declare function runGraph(subcommandRaw: string, id: string | undefined, target: string | undefined, options: GraphCommandOptions, global: GlobalOptions): Promise<ProjectedGraphResult>;
+export declare function runGraph(subcommandRaw:string,id:string | undefined,target:string | undefined,options:GraphCommandOptions,global:GlobalOptions):Promise<ProjectedGraphResult>;