@unbrained/pm-cli 2026.7.16 → 2026.7.18

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

@@ -0,0 +1,108 @@
+/**
+ * @module sdk/graph/governance
+ *
+ * Policy-aware relationship-graph quality audit shared by validation, health,
+ * and package governance surfaces. The audit inspects one assembled workspace
+ * graph and reports machine-readable findings — integrity gaps, ordering
+ * cycles, duplicated edge spellings, stale lifecycle blocks, and coverage
+ * outliers — without inventing edges or assuming that sparse connectivity is
+ * defective. Findings gate severity on lifecycle: contradictions confined to
+ * terminal items downgrade to informational `legacy_*` codes because repairing
+ * them would mutate closed history. Every finding names the violated policy,
+ * carries a deterministic bounded sample, and proposes a safe next action so
+ * agents can plan remediation without re-deriving context.
+ */
+import type { RelationshipEdge } from "../relationships.js";
+import type { WorkspaceRelationshipAssembly } from "./assembly.js";
+/** Severity ladder shared by every relationship audit finding. */
+export type RelationshipAuditSeverity = "error" | "warning" | "info";
+/** Machine-readable identifier for one relationship audit finding family. */
+export type RelationshipAuditFindingCode = "missing_reference_active" | "missing_reference_terminal" | "legacy_no_blocker_sentinel" | "ordering_cycle" | "legacy_ordering_cycle" | "duplicate_edge" | "legacy_duplicate_edge" | "stale_lifecycle_block" | "isolated_active_node" | "sparse_active_node";
+/** One policy-aware relationship audit finding with bounded evidence. */
+export interface RelationshipAuditFinding {
+    /** Machine-readable finding family identifier. */
+    code: RelationshipAuditFindingCode;
+    /** Severity of the violated policy. */
+    severity: RelationshipAuditSeverity;
+    /** Policy statement this finding violates. */
+    policy: string;
+    /** Human-readable summary including the affected count. */
+    message: string;
+    /** Total number of affected subjects, independent of sample bounding. */
+    count: number;
+    /** Deterministic bounded sample of affected subjects. */
+    sample: string[];
+    /** Whether {@link sample} was truncated by the configured sample bound. */
+    sample_truncated: boolean;
+    /** Safe machine-actionable next step; audits never invent or auto-apply edges. */
+    remediation: string;
+}
+/** Aggregate structural coverage metrics for one assembled workspace graph. */
+export interface RelationshipCoverageProfile {
+    /** Total indexed nodes including materialized missing placeholders. */
+    nodes: number;
+    /** Total deduplicated indexed edges. */
+    edges: number;
+    /** Deterministic per-kind edge counts. */
+    edges_by_kind: Record<string, number>;
+    /** Nodes whose lifecycle status is active (non-terminal, non-missing). */
+    active_nodes: number;
+    /** Materialized placeholder nodes for referenced-but-absent items. */
+    missing_nodes: number;
+    /** Active nodes with no incident edges at all. */
+    isolated_active_nodes: number;
+    /** Active nodes with at most one incident edge, isolates included. */
+    degree_leq_one_active_nodes: 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;
+    /** Blocked-lifecycle predicate for stale-block detection; defaults to `status === "blocked"`. */
+    isBlocked?: (status: string) => boolean;
+    /** Node identifiers that are explicitly valid isolates (roots, archives, scratch work). */
+    exemptIsolates?: readonly string[];
+    /** Maximum sample entries retained per finding; defaults to 25. */
+    maxSampleSize?: number;
+    /** Abort signal checked between finding families. */
+    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[];
+    /** Structural coverage metrics computed during the audit. */
+    profile: RelationshipCoverageProfile;
+}
+/** One duplicate-edge group in semantic orientation with its stored spellings. */
+export interface DuplicateRelationshipEdgeGroup {
+    /** Semantic tail node shared by every stored spelling. */
+    from: string;
+    /** Semantic head node shared by every stored spelling. */
+    to: string;
+    /** Stored parallel edges sorted by kind. */
+    edges: RelationshipEdge[];
+}
+/** Format one duplicate-edge group as a compact deterministic evidence 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
+ * spelling in semantic orientation, so a reciprocal pair such as
+ * `A blocked_by B` plus `B blocks A` collapses onto one oriented endpoint
+ * pair. Only groups holding at least two stored spellings are returned, in
+ * 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[];
+/**
+ * Audit one assembled workspace relationship graph against the shared
+ * governance policy and return deterministic machine-readable findings plus a
+ * structural coverage profile.
+ *
+ * The audit is read-only and never proposes inventing an edge: integrity
+ * findings report evidence for investigation, coverage findings honor explicit
+ * 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;

package/dist/sdk/graph/governance.js

@@ -0,0 +1,360 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a78eee2f-0423-565f-91b6-88d0ab46d529")}catch(e){}}();
+import { isTransitiveKind, orientTransitiveEdge, transitiveFamilyKey, } from "./analytics.js";
+/** Default bounded sample size applied to every finding family. */
+const DEFAULT_MAX_SAMPLE_SIZE = 25;
+/** Rank used to order findings by decreasing severity. */
+const SEVERITY_RANK = {
+    error: 0,
+    warning: 1,
+    info: 2,
+};
+/** Build one finding with deterministic bounded sampling over sorted subjects. */
+function buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation) {
+    const sorted = [...subjects].sort((left, right) => left.localeCompare(right));
+    return {
+        code,
+        severity,
+        policy,
+        message: describe(sorted.length),
+        count: sorted.length,
+        sample: sorted.slice(0, maxSampleSize),
+        sample_truncated: sorted.length > maxSampleSize,
+        remediation,
+    };
+}
+/** Resolve the ordering-only successor adjacency for cycle analysis. */
+function buildOrderingAdjacency(assembly) {
+    const registry = assembly.graph.registry();
+    const successors = new Map();
+    for (const edge of assembly.graph.edges()) {
+        const definition = registry.require(edge.kind);
+        if (!definition.ordering)
+            continue;
+        // Orient every ordering edge predecessor -> successor so inverse spellings
+        // (blocked_by/blocks) land in one canonical execution-order digraph.
+        const [predecessor, successor] = (definition.precedence ?? "source_before_target") ===
+            "target_before_source"
+            ? [edge.target, edge.source]
+            : [edge.source, edge.target];
+        const adjacent = successors.get(predecessor);
+        if (adjacent)
+            adjacent.push(successor);
+        else
+            successors.set(predecessor, [successor]);
+    }
+    for (const adjacent of successors.values())
+        adjacent.sort((left, right) => left.localeCompare(right));
+    return successors;
+}
+/** Register one newly discovered Tarjan node. */
+function registerTarjanNode(node, state) {
+    state.indexes.set(node, state.nextIndex);
+    state.lowLinks.set(node, state.nextIndex);
+    state.nextIndex += 1;
+    state.stack.push(node);
+    state.onStack.add(node);
+}
+/** Visit one pending successor, returning whether the frame had work left. */
+function visitNextTarjanNeighbor(frame, frames, successors, state) {
+    const neighbors = successors.get(frame.node) ?? [];
+    if (frame.neighborIndex >= neighbors.length)
+        return false;
+    const neighbor = neighbors[frame.neighborIndex];
+    frame.neighborIndex += 1;
+    if (!state.indexes.has(neighbor)) {
+        registerTarjanNode(neighbor, state);
+        frames.push({ node: neighbor, neighborIndex: 0 });
+    }
+    else if (state.onStack.has(neighbor)) {
+        state.lowLinks.set(frame.node, Math.min(state.lowLinks.get(frame.node), state.indexes.get(neighbor)));
+    }
+    return true;
+}
+/** Complete one Tarjan frame and emit its component when it is a root. */
+function completeTarjanFrame(frame, frames, successors, state) {
+    frames.pop();
+    const parent = frames.at(-1);
+    if (parent)
+        state.lowLinks.set(parent.node, Math.min(state.lowLinks.get(parent.node), state.lowLinks.get(frame.node)));
+    if (state.lowLinks.get(frame.node) !== state.indexes.get(frame.node))
+        return;
+    const component = [];
+    while (true) {
+        const member = state.stack.pop();
+        state.onStack.delete(member);
+        component.push(member);
+        if (member === frame.node)
+            break;
+    }
+    if (component.length > 1 ||
+        (component.length === 1 &&
+            successors.get(component[0])?.includes(component[0])))
+        state.components.push(component.sort((left, right) => left.localeCompare(right)));
+}
+/**
+ * Enumerate strongly connected components with more than one member over the
+ * ordering-only digraph using an iterative Tarjan traversal. Only order-bearing
+ * kinds participate: associative kinds such as `related` cannot create
+ * execution-order contradictions and stay out of cycle analysis by policy.
+ */
+function collectOrderingCycles(successors) {
+    const state = {
+        indexes: new Map(),
+        lowLinks: new Map(),
+        onStack: new Set(),
+        stack: [],
+        components: [],
+        nextIndex: 0,
+    };
+    const roots = [...successors.keys()].sort((left, right) => left.localeCompare(right));
+    for (const root of roots) {
+        if (state.indexes.has(root))
+            continue;
+        // Explicit frame stack keeps the traversal safe on deep dependency chains.
+        const frames = [{ node: root, neighborIndex: 0 }];
+        registerTarjanNode(root, state);
+        while (frames.length > 0) {
+            const frame = frames.at(-1);
+            if (visitNextTarjanNeighbor(frame, frames, successors, state))
+                continue;
+            completeTarjanFrame(frame, frames, successors, state);
+        }
+    }
+    return state.components.sort((left, right) => left[0].localeCompare(right[0]));
+}
+/** Format one dangling reference as a compact deterministic evidence string. */
+function formatDanglingReference(reference) {
+    return `${reference.holder_id} -> ${reference.target_id} (${reference.kind})`;
+}
+/** Append one finding only when its subject collection is non-empty. */
+function appendFinding(findings, subjects, maxSampleSize, code, severity, policy, describe, remediation) {
+    if (subjects.length === 0)
+        return;
+    findings.push(buildFinding(code, severity, policy, describe, subjects, maxSampleSize, remediation));
+}
+/** Collect dangling-reference and retired-sentinel governance findings. */
+function collectIntegrityFindings(assembly, isTerminal, maxSampleSize) {
+    const findings = [];
+    const references = [
+        ...assembly.dangling.active,
+        ...assembly.dangling.legacy_terminal,
+    ].filter((reference) => !reference.no_active_blocker_sentinel);
+    appendFinding(findings, references
+        .filter((reference) => !isTerminal(reference.holder_status))
+        .map(formatDanglingReference), maxSampleSize, "missing_reference_active", "error", "Active items must not reference absent targets; missing prerequisites distort scheduling.", (count) => `${count} active dangling reference(s) to absent items`, "Restore or re-create the referenced item, or remove/retype the reference on the holder.");
+    appendFinding(findings, references
+        .filter((reference) => isTerminal(reference.holder_status))
+        .map(formatDanglingReference), maxSampleSize, "missing_reference_terminal", "info", "Terminal items may retain historical references, but absent targets remain unexplainable context.", (count) => `${count} terminal dangling reference(s) to absent items`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
+    appendFinding(findings, assembly.dangling.no_active_blocker_sentinels.map(formatDanglingReference), maxSampleSize, "legacy_no_blocker_sentinel", "info", "The pre-structured-dependency no-active-blocker sentinel is retired; real edges carry blocker state.", (count) => `${count} legacy no-active-blocker sentinel reference(s)`, "Delete the sentinel reference; blocker state is derived from blocked_by edges.");
+    return findings;
+}
+/** Decide whether one audited node still participates in active scheduling. */
+function isActiveAuditMember(member, nodeStates) {
+    const state = nodeStates.get(member);
+    // A trimmed or custom assembly may omit a member's details. Treat that
+    // unknown lifecycle conservatively as active so contradictions are never
+    // silently downgraded to legacy history debt.
+    if (!state)
+        return true;
+    return !state.terminal;
+}
+/** Collect ordering-cycle and lifecycle-block governance findings. */
+function collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize) {
+    const findings = [];
+    const orderingAdjacency = buildOrderingAdjacency(assembly);
+    for (const cycle of collectOrderingCycles(orderingAdjacency)) {
+        // A cycle whose members are all terminal is a historical contradiction:
+        // it cannot make live work unschedulable, and "repairing" it would touch
+        // closed items (changelog drag), so it downgrades to informational debt.
+        const active = cycle.some((member) => isActiveAuditMember(member, nodeStates));
+        findings.push(active
+            ? buildFinding("ordering_cycle", "error", "Order-bearing relationship kinds must stay acyclic; a cycle makes every member unschedulable.", (count) => `execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Remove or retype one ordering edge inside the cycle, or split the work so precedence is linear.")
+            : buildFinding("legacy_ordering_cycle", "info", "Ordering cycles between exclusively terminal items are historical contradictions with no scheduling effect.", (count) => `terminal-only execution-order cycle across ${count} item(s)`, cycle, maxSampleSize, "Leave as history debt, or clean up in a dedicated changelog-safe closed-item batch; never repair closed items ad hoc."));
+    }
+    const predecessorsByNode = new Map();
+    for (const [predecessor, adjacent] of orderingAdjacency)
+        for (const successor of adjacent) {
+            const predecessors = predecessorsByNode.get(successor);
+            if (predecessors)
+                predecessors.push(predecessor);
+            else
+                predecessorsByNode.set(successor, [predecessor]);
+        }
+    const staleLifecycleBlocks = [...nodeStates.values()]
+        .filter((state) => !state.missing &&
+        !state.terminal &&
+        isBlocked(state.status) &&
+        !(predecessorsByNode.get(state.id) ?? []).some((predecessor) => {
+            const predecessorState = nodeStates.get(predecessor);
+            // A trimmed/custom assembly may omit predecessor details. Treat that
+            // unknown state conservatively as potentially open instead of
+            // falsely declaring the lifecycle block stale.
+            return predecessorState === undefined || !predecessorState.terminal;
+        }))
+        .map((state) => state.id);
+    appendFinding(findings, staleLifecycleBlocks, maxSampleSize, "stale_lifecycle_block", "warning", "A blocked lifecycle status must be backed by at least one open ordering predecessor.", (count) => `${count} status-blocked item(s) with no open blocker edge`, "Re-open the missing prerequisite as an edge, or move the item back to an active status.");
+    return findings;
+}
+/** Format one duplicate-edge group as a compact deterministic evidence string. */
+export function formatDuplicateEdgeGroup(group) {
+    const kinds = group.edges
+        .map((edge) => edge.kind)
+        .sort((left, right) => left.localeCompare(right));
+    return `${group.from} -> ${group.to} (${kinds.join(" + ")})`;
+}
+/**
+ * Collect the groups of parallel same-family stored edges over the directed
+ * ordering and hierarchy families. Each family joins a kind with its inverse
+ * spelling in semantic orientation, so a reciprocal pair such as
+ * `A blocked_by B` plus `B blocks A` collapses onto one oriented endpoint
+ * pair. Only groups holding at least two stored spellings are returned, in
+ * deterministic orientation order with per-group edges sorted by kind, source,
+ * then target — the exact stored identities remediation planning targets.
+ */
+export function collectDuplicateRelationshipEdgeGroups(assembly) {
+    const registry = assembly.graph.registry();
+    const groups = new Map();
+    for (const edge of assembly.graph.edges()) {
+        const definition = registry.require(edge.kind);
+        if (!isTransitiveKind(definition))
+            continue;
+        const oriented = orientTransitiveEdge(edge, definition);
+        if (oriented.from === oriented.to)
+            continue;
+        const key = `${transitiveFamilyKey(definition)}::${oriented.from}::${oriented.to}`;
+        const group = groups.get(key);
+        if (group)
+            group.edges.push(edge);
+        else
+            groups.set(key, { ...oriented, edges: [edge] });
+    }
+    const duplicated = [...groups.values()].filter((group) => group.edges.length >= 2);
+    // Within one oriented group every stored spelling has a distinct kind: a
+    // same-kind restatement of the same oriented pair would carry identical
+    // endpoints and is deduplicated by edge identity during graph construction.
+    for (const group of duplicated)
+        group.edges.sort((left, right) => left.kind.localeCompare(right.kind));
+    return duplicated.sort((left, right) => left.from.localeCompare(right.from) || left.to.localeCompare(right.to));
+}
+/**
+ * Collect duplicate stored-edge findings from the oriented duplicate groups.
+ * Transitive-reduction redundancy analysis deliberately skips the direct edge
+ * under test, so these exact parallels are invisible there and this is the
+ * only surface that reports them.
+ */
+function collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize) {
+    const active = [];
+    const legacy = [];
+    for (const group of collectDuplicateRelationshipEdgeGroups(assembly)) {
+        const subjects = isActiveAuditMember(group.from, nodeStates) ||
+            isActiveAuditMember(group.to, nodeStates)
+            ? active
+            : legacy;
+        subjects.push(formatDuplicateEdgeGroup(group));
+    }
+    const findings = [];
+    appendFinding(findings, active, maxSampleSize, "duplicate_edge", "info", "One semantic relationship should be stored once; parallel same-family spellings (reciprocal inverse pairs included) add no information and skew degree metrics.", (count) => `${count} duplicated relationship(s) between active endpoints`, "Remove all but one stored spelling of the relationship; keep the canonical direction the holder declared first.");
+    appendFinding(findings, legacy, maxSampleSize, "legacy_duplicate_edge", "info", "Duplicated spellings between exclusively terminal items are historical noise with no scheduling effect.", (count) => `${count} duplicated relationship(s) between terminal endpoints`, "Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.");
+    return findings;
+}
+/** Compute structural coverage metrics and coverage-policy findings. */
+function collectCoverageReport(assembly, nodeStates, exemptIsolates, maxSampleSize, edgesByKind) {
+    let activeNodes = 0;
+    let missingNodes = 0;
+    let isolatedActiveNodes = 0;
+    let degreeLeqOneActive = 0;
+    const isolates = [];
+    const sparse = [];
+    for (const id of assembly.graph.nodes()) {
+        const state = nodeStates.get(id);
+        /* c8 ignore next -- every graph node originates from assembly details by construction */
+        if (!state)
+            continue;
+        if (state.missing) {
+            missingNodes += 1;
+            continue;
+        }
+        if (state.terminal)
+            continue;
+        activeNodes += 1;
+        const degree = assembly.graph.incidentEdges(id).length;
+        if (degree > 1)
+            continue;
+        degreeLeqOneActive += 1;
+        if (degree === 0)
+            isolatedActiveNodes += 1;
+        if (exemptIsolates.has(id.toLowerCase()))
+            continue;
+        if (degree === 0)
+            isolates.push(id);
+        else
+            sparse.push(id);
+    }
+    const findings = [];
+    appendFinding(findings, isolates, maxSampleSize, "isolated_active_node", "warning", "Active work should be reachable from the graph unless explicitly declared a valid isolate.", (count) => `${count} active item(s) with no relationships`, "Link the item to its parent, prerequisite, or origin — or register it as an exempt isolate.");
+    appendFinding(findings, sparse, maxSampleSize, "sparse_active_node", "info", "Active items with a single edge often miss an honest semantic partner; sparse is not automatically defective.", (count) => `${count} active item(s) with exactly one relationship`, "Investigate for an honest second edge (story->task, defect family, cross-epic complement); do not fabricate one.");
+    return {
+        findings,
+        profile: {
+            nodes: assembly.graph.nodes().length,
+            edges: assembly.graph.edges().length,
+            edges_by_kind: Object.fromEntries(Object.entries(edgesByKind).sort(([left], [right]) => left.localeCompare(right))),
+            active_nodes: activeNodes,
+            missing_nodes: missingNodes,
+            isolated_active_nodes: isolatedActiveNodes,
+            degree_leq_one_active_nodes: degreeLeqOneActive,
+        },
+    };
+}
+/**
+ * Audit one assembled workspace relationship graph against the shared
+ * governance policy and return deterministic machine-readable findings plus a
+ * structural coverage profile.
+ *
+ * The audit is read-only and never proposes inventing an edge: integrity
+ * findings report evidence for investigation, coverage findings honor explicit
+ * isolate exemptions, and cycle findings enumerate the strongly connected
+ * members so callers can decide which edge to retype, remove, or waive.
+ */
+export function auditWorkspaceRelationshipGraph(assembly, options = {}) {
+    const isTerminal = options.isTerminal ??
+        ((status) => status === "closed" || status === "canceled");
+    const isBlocked = options.isBlocked ?? ((status) => status === "blocked");
+    const maxSampleSize = options.maxSampleSize ?? DEFAULT_MAX_SAMPLE_SIZE;
+    if (!Number.isInteger(maxSampleSize) || maxSampleSize < 1)
+        throw new TypeError(`Invalid audit sample bound: ${String(options.maxSampleSize)}`);
+    const exemptIsolates = new Set((options.exemptIsolates ?? [])
+        .filter((id) => typeof id === "string")
+        .map((id) => id.trim().toLowerCase()));
+    const nodeStates = new Map(assembly.details.map((detail) => [
+        detail.id,
+        {
+            id: detail.id,
+            status: detail.status,
+            missing: assembly.missingIdSet.has(detail.id.toLowerCase()),
+            terminal: isTerminal(detail.status),
+        },
+    ]));
+    options.signal?.throwIfAborted();
+    const edgesByKind = {};
+    for (const edge of assembly.graph.edges())
+        edgesByKind[edge.kind] = (edgesByKind[edge.kind] ?? 0) + 1;
+    const findings = collectIntegrityFindings(assembly, isTerminal, maxSampleSize);
+    options.signal?.throwIfAborted();
+    findings.push(...collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize));
+    options.signal?.throwIfAborted();
+    findings.push(...collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize));
+    options.signal?.throwIfAborted();
+    const coverage = collectCoverageReport(assembly, nodeStates, exemptIsolates, maxSampleSize, edgesByKind);
+    findings.push(...coverage.findings);
+    findings.sort((left, right) => SEVERITY_RANK[left.severity] - SEVERITY_RANK[right.severity] ||
+        left.code.localeCompare(right.code) ||
+        left.sample[0].localeCompare(right.sample[0]));
+    return {
+        findings,
+        profile: coverage.profile,
+    };
+}
+//# sourceMappingURL=governance.js.map
+//# debugId=a78eee2f-0423-565f-91b6-88d0ab46d529

package/dist/sdk/graph/governance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"governance.js","sources":["sdk/graph/governance.ts"],"sourceRoot":"/","sourcesContent":["/**\n * @module sdk/graph/governance\n *\n * Policy-aware relationship-graph quality audit shared by validation, health,\n * and package governance surfaces. The audit inspects one assembled workspace\n * graph and reports machine-readable findings — integrity gaps, ordering\n * cycles, duplicated edge spellings, stale lifecycle blocks, and coverage\n * outliers — without inventing edges or assuming that sparse connectivity is\n * defective. Findings gate severity on lifecycle: contradictions confined to\n * terminal items downgrade to informational `legacy_*` codes because repairing\n * them would mutate closed history. Every finding names the violated policy,\n * carries a deterministic bounded sample, and proposes a safe next action so\n * agents can plan remediation without re-deriving context.\n */\nimport type { RelationshipEdge } from \"../relationships.js\";\nimport {\n  isTransitiveKind,\n  orientTransitiveEdge,\n  transitiveFamilyKey,\n} from \"./analytics.js\";\nimport type { WorkspaceRelationshipAssembly } from \"./assembly.js\";\n\n/** Severity ladder shared by every relationship audit finding. */\nexport type RelationshipAuditSeverity = \"error\" | \"warning\" | \"info\";\n\n/** Machine-readable identifier for one relationship audit finding family. */\nexport type RelationshipAuditFindingCode =\n  | \"missing_reference_active\"\n  | \"missing_reference_terminal\"\n  | \"legacy_no_blocker_sentinel\"\n  | \"ordering_cycle\"\n  | \"legacy_ordering_cycle\"\n  | \"duplicate_edge\"\n  | \"legacy_duplicate_edge\"\n  | \"stale_lifecycle_block\"\n  | \"isolated_active_node\"\n  | \"sparse_active_node\";\n\n/** One policy-aware relationship audit finding with bounded evidence. */\nexport interface RelationshipAuditFinding {\n  /** Machine-readable finding family identifier. */\n  code: RelationshipAuditFindingCode;\n  /** Severity of the violated policy. */\n  severity: RelationshipAuditSeverity;\n  /** Policy statement this finding violates. */\n  policy: string;\n  /** Human-readable summary including the affected count. */\n  message: string;\n  /** Total number of affected subjects, independent of sample bounding. */\n  count: number;\n  /** Deterministic bounded sample of affected subjects. */\n  sample: string[];\n  /** Whether {@link sample} was truncated by the configured sample bound. */\n  sample_truncated: boolean;\n  /** Safe machine-actionable next step; audits never invent or auto-apply edges. */\n  remediation: string;\n}\n\n/** Aggregate structural coverage metrics for one assembled workspace graph. */\nexport interface RelationshipCoverageProfile {\n  /** Total indexed nodes including materialized missing placeholders. */\n  nodes: number;\n  /** Total deduplicated indexed edges. */\n  edges: number;\n  /** Deterministic per-kind edge counts. */\n  edges_by_kind: Record<string, number>;\n  /** Nodes whose lifecycle status is active (non-terminal, non-missing). */\n  active_nodes: number;\n  /** Materialized placeholder nodes for referenced-but-absent items. */\n  missing_nodes: number;\n  /** Active nodes with no incident edges at all. */\n  isolated_active_nodes: number;\n  /** Active nodes with at most one incident edge, isolates included. */\n  degree_leq_one_active_nodes: number;\n}\n\n/** Tuning and policy inputs accepted by the relationship audit. */\nexport interface RelationshipAuditOptions {\n  /** Terminal-lifecycle predicate; defaults to the built-in closed/canceled statuses. */\n  isTerminal?: (status: string) => boolean;\n  /** Blocked-lifecycle predicate for stale-block detection; defaults to `status === \"blocked\"`. */\n  isBlocked?: (status: string) => boolean;\n  /** Node identifiers that are explicitly valid isolates (roots, archives, scratch work). */\n  exemptIsolates?: readonly string[];\n  /** Maximum sample entries retained per finding; defaults to 25. */\n  maxSampleSize?: number;\n  /** Abort signal checked between finding families. */\n  signal?: AbortSignal;\n}\n\n/** Complete deterministic result of one relationship-graph audit. */\nexport interface RelationshipAuditReport {\n  /** Findings ordered by severity, then code, then first sample subject. */\n  findings: RelationshipAuditFinding[];\n  /** Structural coverage metrics computed during the audit. */\n  profile: RelationshipCoverageProfile;\n}\n\n/** Default bounded sample size applied to every finding family. */\nconst DEFAULT_MAX_SAMPLE_SIZE = 25;\n\n/** Rank used to order findings by decreasing severity. */\nconst SEVERITY_RANK: Record<RelationshipAuditSeverity, number> = {\n  error: 0,\n  warning: 1,\n  info: 2,\n};\n\n/** Internal per-node lifecycle classification resolved once per audit. */\ninterface AuditNodeState {\n  /** Original-case node identifier. */\n  id: string;\n  /** Raw lifecycle status string from assembly details. */\n  status: string;\n  /** Whether the node is a materialized missing placeholder. */\n  missing: boolean;\n  /** Whether the node's lifecycle status is terminal. */\n  terminal: boolean;\n}\n\n/** Mutable state shared by iterative Tarjan frames. */\ninterface TarjanState {\n  /** Discovery index assigned to each visited node. */\n  indexes: Map<string, number>;\n  /** Lowest reachable discovery index per visited node. */\n  lowLinks: Map<string, number>;\n  /** Nodes that still belong to an unfinished component. */\n  onStack: Set<string>;\n  /** Component-membership stack. */\n  stack: string[];\n  /** Completed cyclic components. */\n  components: string[][];\n  /** Discovery index assigned to the next unseen node. */\n  nextIndex: number;\n}\n\n/** One explicit depth-first frame used by iterative Tarjan traversal. */\ninterface TarjanFrame {\n  /** Node currently being expanded. */\n  node: string;\n  /** Index of the next successor to inspect. */\n  neighborIndex: number;\n}\n\n/** Build one finding with deterministic bounded sampling over sorted subjects. */\nfunction buildFinding(\n  code: RelationshipAuditFindingCode,\n  severity: RelationshipAuditSeverity,\n  policy: string,\n  describe: (count: number) => string,\n  subjects: readonly string[],\n  maxSampleSize: number,\n  remediation: string,\n): RelationshipAuditFinding {\n  const sorted = [...subjects].sort((left, right) => left.localeCompare(right));\n  return {\n    code,\n    severity,\n    policy,\n    message: describe(sorted.length),\n    count: sorted.length,\n    sample: sorted.slice(0, maxSampleSize),\n    sample_truncated: sorted.length > maxSampleSize,\n    remediation,\n  };\n}\n/** Resolve the ordering-only successor adjacency for cycle analysis. */\nfunction buildOrderingAdjacency(\n  assembly: WorkspaceRelationshipAssembly,\n): Map<string, string[]> {\n  const registry = assembly.graph.registry();\n  const successors = new Map<string, string[]>();\n  for (const edge of assembly.graph.edges()) {\n    const definition = registry.require(edge.kind);\n    if (!definition.ordering) continue;\n    // Orient every ordering edge predecessor -> successor so inverse spellings\n    // (blocked_by/blocks) land in one canonical execution-order digraph.\n    const [predecessor, successor] =\n      (definition.precedence ?? \"source_before_target\") ===\n      \"target_before_source\"\n        ? [edge.target, edge.source]\n        : [edge.source, edge.target];\n    const adjacent = successors.get(predecessor);\n    if (adjacent) adjacent.push(successor);\n    else successors.set(predecessor, [successor]);\n  }\n  for (const adjacent of successors.values())\n    adjacent.sort((left, right) => left.localeCompare(right));\n  return successors;\n}\n\n/** Register one newly discovered Tarjan node. */\nfunction registerTarjanNode(node: string, state: TarjanState): void {\n  state.indexes.set(node, state.nextIndex);\n  state.lowLinks.set(node, state.nextIndex);\n  state.nextIndex += 1;\n  state.stack.push(node);\n  state.onStack.add(node);\n}\n\n/** Visit one pending successor, returning whether the frame had work left. */\nfunction visitNextTarjanNeighbor(\n  frame: TarjanFrame,\n  frames: TarjanFrame[],\n  successors: Map<string, string[]>,\n  state: TarjanState,\n): boolean {\n  const neighbors = successors.get(frame.node) ?? [];\n  if (frame.neighborIndex >= neighbors.length) return false;\n  const neighbor = neighbors[frame.neighborIndex]!;\n  frame.neighborIndex += 1;\n  if (!state.indexes.has(neighbor)) {\n    registerTarjanNode(neighbor, state);\n    frames.push({ node: neighbor, neighborIndex: 0 });\n  } else if (state.onStack.has(neighbor)) {\n    state.lowLinks.set(\n      frame.node,\n      Math.min(state.lowLinks.get(frame.node)!, state.indexes.get(neighbor)!),\n    );\n  }\n  return true;\n}\n\n/** Complete one Tarjan frame and emit its component when it is a root. */\nfunction completeTarjanFrame(\n  frame: TarjanFrame,\n  frames: TarjanFrame[],\n  successors: Map<string, string[]>,\n  state: TarjanState,\n): void {\n  frames.pop();\n  const parent = frames.at(-1);\n  if (parent)\n    state.lowLinks.set(\n      parent.node,\n      Math.min(\n        state.lowLinks.get(parent.node)!,\n        state.lowLinks.get(frame.node)!,\n      ),\n    );\n  if (state.lowLinks.get(frame.node) !== state.indexes.get(frame.node)) return;\n  const component: string[] = [];\n  while (true) {\n    const member = state.stack.pop()!;\n    state.onStack.delete(member);\n    component.push(member);\n    if (member === frame.node) break;\n  }\n  if (\n    component.length > 1 ||\n    (component.length === 1 &&\n      successors.get(component[0]!)?.includes(component[0]!))\n  )\n    state.components.push(\n      component.sort((left, right) => left.localeCompare(right)),\n    );\n}\n\n/**\n * Enumerate strongly connected components with more than one member over the\n * ordering-only digraph using an iterative Tarjan traversal. Only order-bearing\n * kinds participate: associative kinds such as `related` cannot create\n * execution-order contradictions and stay out of cycle analysis by policy.\n */\nfunction collectOrderingCycles(successors: Map<string, string[]>): string[][] {\n  const state: TarjanState = {\n    indexes: new Map(),\n    lowLinks: new Map(),\n    onStack: new Set(),\n    stack: [],\n    components: [],\n    nextIndex: 0,\n  };\n  const roots = [...successors.keys()].sort((left, right) =>\n    left.localeCompare(right),\n  );\n  for (const root of roots) {\n    if (state.indexes.has(root)) continue;\n    // Explicit frame stack keeps the traversal safe on deep dependency chains.\n    const frames: TarjanFrame[] = [{ node: root, neighborIndex: 0 }];\n    registerTarjanNode(root, state);\n    while (frames.length > 0) {\n      const frame = frames.at(-1)!;\n      if (visitNextTarjanNeighbor(frame, frames, successors, state)) continue;\n      completeTarjanFrame(frame, frames, successors, state);\n    }\n  }\n  return state.components.sort((left, right) =>\n    left[0]!.localeCompare(right[0]!),\n  );\n}\n\n/** Format one dangling reference as a compact deterministic evidence string. */\nfunction formatDanglingReference(reference: {\n  holder_id: string;\n  target_id: string;\n  kind: string;\n}): string {\n  return `${reference.holder_id} -> ${reference.target_id} (${reference.kind})`;\n}\n\n/** Append one finding only when its subject collection is non-empty. */\nfunction appendFinding(\n  findings: RelationshipAuditFinding[],\n  subjects: readonly string[],\n  maxSampleSize: number,\n  code: RelationshipAuditFindingCode,\n  severity: RelationshipAuditSeverity,\n  policy: string,\n  describe: (count: number) => string,\n  remediation: string,\n): void {\n  if (subjects.length === 0) return;\n  findings.push(\n    buildFinding(\n      code,\n      severity,\n      policy,\n      describe,\n      subjects,\n      maxSampleSize,\n      remediation,\n    ),\n  );\n}\n\n/** Collect dangling-reference and retired-sentinel governance findings. */\nfunction collectIntegrityFindings(\n  assembly: WorkspaceRelationshipAssembly,\n  isTerminal: (status: string) => boolean,\n  maxSampleSize: number,\n): RelationshipAuditFinding[] {\n  const findings: RelationshipAuditFinding[] = [];\n  const references = [\n    ...assembly.dangling.active,\n    ...assembly.dangling.legacy_terminal,\n  ].filter((reference) => !reference.no_active_blocker_sentinel);\n  appendFinding(\n    findings,\n    references\n      .filter((reference) => !isTerminal(reference.holder_status))\n      .map(formatDanglingReference),\n    maxSampleSize,\n    \"missing_reference_active\",\n    \"error\",\n    \"Active items must not reference absent targets; missing prerequisites distort scheduling.\",\n    (count) => `${count} active dangling reference(s) to absent items`,\n    \"Restore or re-create the referenced item, or remove/retype the reference on the holder.\",\n  );\n  appendFinding(\n    findings,\n    references\n      .filter((reference) => isTerminal(reference.holder_status))\n      .map(formatDanglingReference),\n    maxSampleSize,\n    \"missing_reference_terminal\",\n    \"info\",\n    \"Terminal items may retain historical references, but absent targets remain unexplainable context.\",\n    (count) => `${count} terminal dangling reference(s) to absent items`,\n    \"Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.\",\n  );\n  appendFinding(\n    findings,\n    assembly.dangling.no_active_blocker_sentinels.map(formatDanglingReference),\n    maxSampleSize,\n    \"legacy_no_blocker_sentinel\",\n    \"info\",\n    \"The pre-structured-dependency no-active-blocker sentinel is retired; real edges carry blocker state.\",\n    (count) => `${count} legacy no-active-blocker sentinel reference(s)`,\n    \"Delete the sentinel reference; blocker state is derived from blocked_by edges.\",\n  );\n  return findings;\n}\n\n/** Decide whether one audited node still participates in active scheduling. */\nfunction isActiveAuditMember(\n  member: string,\n  nodeStates: Map<string, AuditNodeState>,\n): boolean {\n  const state = nodeStates.get(member);\n  // A trimmed or custom assembly may omit a member's details. Treat that\n  // unknown lifecycle conservatively as active so contradictions are never\n  // silently downgraded to legacy history debt.\n  if (!state) return true;\n  return !state.terminal;\n}\n\n/** Collect ordering-cycle and lifecycle-block governance findings. */\nfunction collectOrderingFindings(\n  assembly: WorkspaceRelationshipAssembly,\n  nodeStates: Map<string, AuditNodeState>,\n  isBlocked: (status: string) => boolean,\n  maxSampleSize: number,\n): RelationshipAuditFinding[] {\n  const findings: RelationshipAuditFinding[] = [];\n  const orderingAdjacency = buildOrderingAdjacency(assembly);\n  for (const cycle of collectOrderingCycles(orderingAdjacency)) {\n    // A cycle whose members are all terminal is a historical contradiction:\n    // it cannot make live work unschedulable, and \"repairing\" it would touch\n    // closed items (changelog drag), so it downgrades to informational debt.\n    const active = cycle.some((member) =>\n      isActiveAuditMember(member, nodeStates),\n    );\n    findings.push(\n      active\n        ? buildFinding(\n            \"ordering_cycle\",\n            \"error\",\n            \"Order-bearing relationship kinds must stay acyclic; a cycle makes every member unschedulable.\",\n            (count) => `execution-order cycle across ${count} item(s)`,\n            cycle,\n            maxSampleSize,\n            \"Remove or retype one ordering edge inside the cycle, or split the work so precedence is linear.\",\n          )\n        : buildFinding(\n            \"legacy_ordering_cycle\",\n            \"info\",\n            \"Ordering cycles between exclusively terminal items are historical contradictions with no scheduling effect.\",\n            (count) => `terminal-only execution-order cycle across ${count} item(s)`,\n            cycle,\n            maxSampleSize,\n            \"Leave as history debt, or clean up in a dedicated changelog-safe closed-item batch; never repair closed items ad hoc.\",\n          ),\n    );\n  }\n  const predecessorsByNode = new Map<string, string[]>();\n  for (const [predecessor, adjacent] of orderingAdjacency)\n    for (const successor of adjacent) {\n      const predecessors = predecessorsByNode.get(successor);\n      if (predecessors) predecessors.push(predecessor);\n      else predecessorsByNode.set(successor, [predecessor]);\n    }\n  const staleLifecycleBlocks = [...nodeStates.values()]\n    .filter(\n      (state) =>\n        !state.missing &&\n        !state.terminal &&\n        isBlocked(state.status) &&\n        !(predecessorsByNode.get(state.id) ?? []).some((predecessor) => {\n          const predecessorState = nodeStates.get(predecessor);\n          // A trimmed/custom assembly may omit predecessor details. Treat that\n          // unknown state conservatively as potentially open instead of\n          // falsely declaring the lifecycle block stale.\n          return predecessorState === undefined || !predecessorState.terminal;\n        }),\n    )\n    .map((state) => state.id);\n  appendFinding(\n    findings,\n    staleLifecycleBlocks,\n    maxSampleSize,\n    \"stale_lifecycle_block\",\n    \"warning\",\n    \"A blocked lifecycle status must be backed by at least one open ordering predecessor.\",\n    (count) => `${count} status-blocked item(s) with no open blocker edge`,\n    \"Re-open the missing prerequisite as an edge, or move the item back to an active status.\",\n  );\n  return findings;\n}\n\n/** One duplicate-edge group in semantic orientation with its stored spellings. */\nexport interface DuplicateRelationshipEdgeGroup {\n  /** Semantic tail node shared by every stored spelling. */\n  from: string;\n  /** Semantic head node shared by every stored spelling. */\n  to: string;\n  /** Stored parallel edges sorted by kind. */\n  edges: RelationshipEdge[];\n}\n\n/** Format one duplicate-edge group as a compact deterministic evidence string. */\nexport function formatDuplicateEdgeGroup(\n  group: DuplicateRelationshipEdgeGroup,\n): string {\n  const kinds = group.edges\n    .map((edge) => edge.kind)\n    .sort((left, right) => left.localeCompare(right));\n  return `${group.from} -> ${group.to} (${kinds.join(\" + \")})`;\n}\n\n/**\n * Collect the groups of parallel same-family stored edges over the directed\n * ordering and hierarchy families. Each family joins a kind with its inverse\n * spelling in semantic orientation, so a reciprocal pair such as\n * `A blocked_by B` plus `B blocks A` collapses onto one oriented endpoint\n * pair. Only groups holding at least two stored spellings are returned, in\n * deterministic orientation order with per-group edges sorted by kind, source,\n * then target — the exact stored identities remediation planning targets.\n */\nexport function collectDuplicateRelationshipEdgeGroups(\n  assembly: WorkspaceRelationshipAssembly,\n): DuplicateRelationshipEdgeGroup[] {\n  const registry = assembly.graph.registry();\n  const groups = new Map<string, DuplicateRelationshipEdgeGroup>();\n  for (const edge of assembly.graph.edges()) {\n    const definition = registry.require(edge.kind);\n    if (!isTransitiveKind(definition)) continue;\n    const oriented = orientTransitiveEdge(edge, definition);\n    if (oriented.from === oriented.to) continue;\n    const key = `${transitiveFamilyKey(definition)}::${oriented.from}::${oriented.to}`;\n    const group = groups.get(key);\n    if (group) group.edges.push(edge);\n    else groups.set(key, { ...oriented, edges: [edge] });\n  }\n  const duplicated = [...groups.values()].filter(\n    (group) => group.edges.length >= 2,\n  );\n  // Within one oriented group every stored spelling has a distinct kind: a\n  // same-kind restatement of the same oriented pair would carry identical\n  // endpoints and is deduplicated by edge identity during graph construction.\n  for (const group of duplicated)\n    group.edges.sort((left, right) => left.kind.localeCompare(right.kind));\n  return duplicated.sort(\n    (left, right) =>\n      left.from.localeCompare(right.from) || left.to.localeCompare(right.to),\n  );\n}\n\n/**\n * Collect duplicate stored-edge findings from the oriented duplicate groups.\n * Transitive-reduction redundancy analysis deliberately skips the direct edge\n * under test, so these exact parallels are invisible there and this is the\n * only surface that reports them.\n */\nfunction collectDuplicateEdgeFindings(\n  assembly: WorkspaceRelationshipAssembly,\n  nodeStates: Map<string, AuditNodeState>,\n  maxSampleSize: number,\n): RelationshipAuditFinding[] {\n  const active: string[] = [];\n  const legacy: string[] = [];\n  for (const group of collectDuplicateRelationshipEdgeGroups(assembly)) {\n    const subjects =\n      isActiveAuditMember(group.from, nodeStates) ||\n      isActiveAuditMember(group.to, nodeStates)\n        ? active\n        : legacy;\n    subjects.push(formatDuplicateEdgeGroup(group));\n  }\n  const findings: RelationshipAuditFinding[] = [];\n  appendFinding(\n    findings,\n    active,\n    maxSampleSize,\n    \"duplicate_edge\",\n    \"info\",\n    \"One semantic relationship should be stored once; parallel same-family spellings (reciprocal inverse pairs included) add no information and skew degree metrics.\",\n    (count) => `${count} duplicated relationship(s) between active endpoints`,\n    \"Remove all but one stored spelling of the relationship; keep the canonical direction the holder declared first.\",\n  );\n  appendFinding(\n    findings,\n    legacy,\n    maxSampleSize,\n    \"legacy_duplicate_edge\",\n    \"info\",\n    \"Duplicated spellings between exclusively terminal items are historical noise with no scheduling effect.\",\n    (count) => `${count} duplicated relationship(s) between terminal endpoints`,\n    \"Leave as history debt or clean up in a dedicated changelog-safe closed-item batch.\",\n  );\n  return findings;\n}\n\n/** Compute structural coverage metrics and coverage-policy findings. */\nfunction collectCoverageReport(\n  assembly: WorkspaceRelationshipAssembly,\n  nodeStates: Map<string, AuditNodeState>,\n  exemptIsolates: Set<string>,\n  maxSampleSize: number,\n  edgesByKind: Record<string, number>,\n): RelationshipAuditReport {\n  let activeNodes = 0;\n  let missingNodes = 0;\n  let isolatedActiveNodes = 0;\n  let degreeLeqOneActive = 0;\n  const isolates: string[] = [];\n  const sparse: string[] = [];\n  for (const id of assembly.graph.nodes()) {\n    const state = nodeStates.get(id);\n    /* c8 ignore next -- every graph node originates from assembly details by construction */\n    if (!state) continue;\n    if (state.missing) {\n      missingNodes += 1;\n      continue;\n    }\n    if (state.terminal) continue;\n    activeNodes += 1;\n    const degree = assembly.graph.incidentEdges(id).length;\n    if (degree > 1) continue;\n    degreeLeqOneActive += 1;\n    if (degree === 0) isolatedActiveNodes += 1;\n    if (exemptIsolates.has(id.toLowerCase())) continue;\n    if (degree === 0) isolates.push(id);\n    else sparse.push(id);\n  }\n  const findings: RelationshipAuditFinding[] = [];\n  appendFinding(\n    findings,\n    isolates,\n    maxSampleSize,\n    \"isolated_active_node\",\n    \"warning\",\n    \"Active work should be reachable from the graph unless explicitly declared a valid isolate.\",\n    (count) => `${count} active item(s) with no relationships`,\n    \"Link the item to its parent, prerequisite, or origin — or register it as an exempt isolate.\",\n  );\n  appendFinding(\n    findings,\n    sparse,\n    maxSampleSize,\n    \"sparse_active_node\",\n    \"info\",\n    \"Active items with a single edge often miss an honest semantic partner; sparse is not automatically defective.\",\n    (count) => `${count} active item(s) with exactly one relationship`,\n    \"Investigate for an honest second edge (story->task, defect family, cross-epic complement); do not fabricate one.\",\n  );\n  return {\n    findings,\n    profile: {\n      nodes: assembly.graph.nodes().length,\n      edges: assembly.graph.edges().length,\n      edges_by_kind: Object.fromEntries(\n        Object.entries(edgesByKind).sort(([left], [right]) =>\n          left.localeCompare(right),\n        ),\n      ),\n      active_nodes: activeNodes,\n      missing_nodes: missingNodes,\n      isolated_active_nodes: isolatedActiveNodes,\n      degree_leq_one_active_nodes: degreeLeqOneActive,\n    },\n  };\n}\n\n/**\n * Audit one assembled workspace relationship graph against the shared\n * governance policy and return deterministic machine-readable findings plus a\n * structural coverage profile.\n *\n * The audit is read-only and never proposes inventing an edge: integrity\n * findings report evidence for investigation, coverage findings honor explicit\n * isolate exemptions, and cycle findings enumerate the strongly connected\n * members so callers can decide which edge to retype, remove, or waive.\n */\nexport function auditWorkspaceRelationshipGraph(\n  assembly: WorkspaceRelationshipAssembly,\n  options: RelationshipAuditOptions = {},\n): RelationshipAuditReport {\n  const isTerminal =\n    options.isTerminal ??\n    ((status: string) => status === \"closed\" || status === \"canceled\");\n  const isBlocked =\n    options.isBlocked ?? ((status: string) => status === \"blocked\");\n  const maxSampleSize = options.maxSampleSize ?? DEFAULT_MAX_SAMPLE_SIZE;\n  if (!Number.isInteger(maxSampleSize) || maxSampleSize < 1)\n    throw new TypeError(\n      `Invalid audit sample bound: ${String(options.maxSampleSize)}`,\n    );\n  const exemptIsolates = new Set(\n    (options.exemptIsolates ?? [])\n      .filter((id): id is string => typeof id === \"string\")\n      .map((id) => id.trim().toLowerCase()),\n  );\n  const nodeStates = new Map<string, AuditNodeState>(\n    assembly.details.map((detail) => [\n      detail.id,\n      {\n        id: detail.id,\n        status: detail.status,\n        missing: assembly.missingIdSet.has(detail.id.toLowerCase()),\n        terminal: isTerminal(detail.status),\n      },\n    ]),\n  );\n  options.signal?.throwIfAborted();\n\n  const edgesByKind: Record<string, number> = {};\n  for (const edge of assembly.graph.edges())\n    edgesByKind[edge.kind] = (edgesByKind[edge.kind] ?? 0) + 1;\n  const findings = collectIntegrityFindings(\n    assembly,\n    isTerminal,\n    maxSampleSize,\n  );\n  options.signal?.throwIfAborted();\n  findings.push(\n    ...collectOrderingFindings(assembly, nodeStates, isBlocked, maxSampleSize),\n  );\n  options.signal?.throwIfAborted();\n  findings.push(\n    ...collectDuplicateEdgeFindings(assembly, nodeStates, maxSampleSize),\n  );\n  options.signal?.throwIfAborted();\n  const coverage = collectCoverageReport(\n    assembly,\n    nodeStates,\n    exemptIsolates,\n    maxSampleSize,\n    edgesByKind,\n  );\n  findings.push(...coverage.findings);\n\n  findings.sort(\n    (left, right) =>\n      SEVERITY_RANK[left.severity] - SEVERITY_RANK[right.severity] ||\n      left.code.localeCompare(right.code) ||\n      left.sample[0]!.localeCompare(right.sample[0]!),\n  );\n  return {\n    findings,\n    profile: coverage.profile,\n  };\n}\n"],"names":[],"mappings":"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","debugId":"a78eee2f-0423-565f-91b6-88d0ab46d529"}

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

@@ -0,0 +1,16 @@
+/**
+ * @module sdk/graph
+ *
+ * Public workspace graph toolkit: one-pass relationship assembly with
+ * missing-reference governance, registry-semantics traversal (hierarchy,
+ * execution order, bounded path enumeration), and the policy-aware
+ * relationship audit. Everything here layers on the dependency-free kernel in
+ * `sdk/relationships` and is safe for CLI, MCP, extension, and non-PM callers.
+ */
+export { computeRelationshipDominators, detectRelationshipCommunities, findRedundantRelationshipEdges, type GraphCommunityOptions, type GraphDominatorOptions, type GraphRedundancyOptions, type RedundantRelationshipEdge, type RelationshipCommunity, type RelationshipCommunityAnalysis, type RelationshipDominatorAnalysis, type RelationshipDominatorRow, } from "./analytics.js";
+export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectMissingDependencyTargetIds, type DanglingDependencyReference, type DanglingDependencyReferenceSummary, type DependencyReferenceHolder, type DependencyReferenceSource, type WorkspaceRelationshipAssembly, type WorkspaceRelationshipItem, type WorkspaceRelationshipNodeDetails, } from "./assembly.js";
+export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, formatDuplicateEdgeGroup, type DuplicateRelationshipEdgeGroup, type RelationshipAuditFinding, type RelationshipAuditFindingCode, type RelationshipAuditOptions, type RelationshipAuditReport, type RelationshipAuditSeverity, type RelationshipCoverageProfile, } from "./governance.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 { GRAPH_SUBCOMMAND_VALUES, parseGraphSubcommand, runGraph, type GraphAnalyzeResult, type GraphAuditResult, type GraphCommandOptions, type GraphCommunitiesResult, type GraphCommunityRow, type GraphDominatorRow, type GraphDominatorsResult, type GraphExecutionSummary, type GraphImpactResult, type GraphImpactRow, type GraphKnowledgeSummary, type GraphPathRow, type GraphPathsResult, type GraphPlanResult, type GraphQueryCost, type GraphRedundancyResult, type GraphRedundancyRow, type GraphResult, type GraphSubcommand, type GraphTraversalResult, } from "./run.js";

package/dist/sdk/graph/index.js

@@ -0,0 +1,20 @@
+/**
+ * @module sdk/graph
+ *
+ * Public workspace graph toolkit: one-pass relationship assembly with
+ * missing-reference governance, registry-semantics traversal (hierarchy,
+ * execution order, bounded path enumeration), and the policy-aware
+ * relationship audit. Everything here layers on the dependency-free kernel in
+ * `sdk/relationships` and is safe for CLI, MCP, extension, and non-PM callers.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="fc1760dc-36e8-522f-8e91-28fa04f269a0")}catch(e){}}();
+export { computeRelationshipDominators, detectRelationshipCommunities, findRedundantRelationshipEdges, } from "./analytics.js";
+export { assembleWorkspaceRelationshipGraph, collectDanglingDependencyReferences, collectMissingDependencyTargetIds, } from "./assembly.js";
+export { auditWorkspaceRelationshipGraph, collectDuplicateRelationshipEdgeGroups, formatDuplicateEdgeGroup, } from "./governance.js";
+export { enumerateRelationshipPaths, hierarchyAncestors, hierarchyDescendants, orderingPredecessors, orderingSuccessors, } from "./traversal.js";
+export { computeWorkspaceGraphFingerprint, resetWorkspaceGraphCache, workspaceGraphCache, WorkspaceGraphCache, } from "./cache.js";
+export { planRelationshipRemediation, } from "./remediation.js";
+export { GRAPH_SUBCOMMAND_VALUES, parseGraphSubcommand, runGraph, } from "./run.js";
+//# sourceMappingURL=index.js.map
+//# debugId=fc1760dc-36e8-522f-8e91-28fa04f269a0

package/dist/sdk/graph/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["sdk/graph/index.ts"],"sourceRoot":"/","sourcesContent":["/**\n * @module sdk/graph\n *\n * Public workspace graph toolkit: one-pass relationship assembly with\n * missing-reference governance, registry-semantics traversal (hierarchy,\n * execution order, bounded path enumeration), and the policy-aware\n * relationship audit. Everything here layers on the dependency-free kernel in\n * `sdk/relationships` and is safe for CLI, MCP, extension, and non-PM callers.\n */\nexport {\n  computeRelationshipDominators,\n  detectRelationshipCommunities,\n  findRedundantRelationshipEdges,\n  type GraphCommunityOptions,\n  type GraphDominatorOptions,\n  type GraphRedundancyOptions,\n  type RedundantRelationshipEdge,\n  type RelationshipCommunity,\n  type RelationshipCommunityAnalysis,\n  type RelationshipDominatorAnalysis,\n  type RelationshipDominatorRow,\n} from \"./analytics.js\";\nexport {\n  assembleWorkspaceRelationshipGraph,\n  collectDanglingDependencyReferences,\n  collectMissingDependencyTargetIds,\n  type DanglingDependencyReference,\n  type DanglingDependencyReferenceSummary,\n  type DependencyReferenceHolder,\n  type DependencyReferenceSource,\n  type WorkspaceRelationshipAssembly,\n  type WorkspaceRelationshipItem,\n  type WorkspaceRelationshipNodeDetails,\n} from \"./assembly.js\";\nexport {\n  auditWorkspaceRelationshipGraph,\n  collectDuplicateRelationshipEdgeGroups,\n  formatDuplicateEdgeGroup,\n  type DuplicateRelationshipEdgeGroup,\n  type RelationshipAuditFinding,\n  type RelationshipAuditFindingCode,\n  type RelationshipAuditOptions,\n  type RelationshipAuditReport,\n  type RelationshipAuditSeverity,\n  type RelationshipCoverageProfile,\n} from \"./governance.js\";\nexport {\n  enumerateRelationshipPaths,\n  hierarchyAncestors,\n  hierarchyDescendants,\n  orderingPredecessors,\n  orderingSuccessors,\n  type GraphPathOptions,\n  type GraphTraversalOptions,\n  type RelationshipPath,\n} from \"./traversal.js\";\nexport {\n  computeWorkspaceGraphFingerprint,\n  resetWorkspaceGraphCache,\n  workspaceGraphCache,\n  WorkspaceGraphCache,\n  type GraphCacheMetadata,\n  type WorkspaceGraphCacheLookup,\n} from \"./cache.js\";\nexport {\n  planRelationshipRemediation,\n  type RelationshipRemediationCode,\n  type RelationshipRemediationConfidence,\n  type RelationshipRemediationOperation,\n  type RelationshipRemediationPlan,\n  type RelationshipRemediationPlanOptions,\n  type RelationshipRemediationStep,\n} from \"./remediation.js\";\nexport {\n  GRAPH_SUBCOMMAND_VALUES,\n  parseGraphSubcommand,\n  runGraph,\n  type GraphAnalyzeResult,\n  type GraphAuditResult,\n  type GraphCommandOptions,\n  type GraphCommunitiesResult,\n  type GraphCommunityRow,\n  type GraphDominatorRow,\n  type GraphDominatorsResult,\n  type GraphExecutionSummary,\n  type GraphImpactResult,\n  type GraphImpactRow,\n  type GraphKnowledgeSummary,\n  type GraphPathRow,\n  type GraphPathsResult,\n  type GraphPlanResult,\n  type GraphQueryCost,\n  type GraphRedundancyResult,\n  type GraphRedundancyRow,\n  type GraphResult,\n  type GraphSubcommand,\n  type GraphTraversalResult,\n} from \"./run.js\";\n"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;;;AACH,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,EAC7B,8BAA8B,GAS/B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kCAAkC,EAClC,mCAAmC,EACnC,iCAAiC,GAQlC,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,+BAA+B,EAC/B,sCAAsC,EACtC,wBAAwB,GAQzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,0BAA0B,EAC1B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,GAInB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,gCAAgC,EAChC,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,GAGpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,2BAA2B,GAO5B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,QAAQ,GAqBT,MAAM,UAAU,CAAC","debugId":"fc1760dc-36e8-522f-8e91-28fa04f269a0"}