@opensip-cli/graph 0.1.0

package/dist/cli/orchestrate/edge-identity.js

@@ -0,0 +1,68 @@
+/**
+ * Shared occurrence/edge IDENTITY — the ONE module that owns how call/dependency
+ * edges are keyed to their owning occurrence and stitched back onto it.
+ *
+ * WHY THIS EXISTS (the drift it closes):
+ *   ADR-0003 mandates edges be keyed by OCCURRENCE — `ownerEdgeKey(bodyHash,
+ *   filePath)` — not by `bodyHash` alone: two functions with byte-identical
+ *   bodies in different files (e.g. `stripStrings` duplicated across the language
+ *   adapters) share a hash, so a hash-only bucket UNIONS their edges, inventing
+ *   phantom cross-package coupling. The EXACT path complied (its resolver returns
+ *   an `ownerEdgeKey`-keyed map; `catalog-builder.stitchEdges` reads it the same
+ *   way). The CROSS-SHARD merge did NOT — it bucketed/stitched by `bc.ownerHash`
+ *   alone (a second, drifting keying scheme). That drift is the root cause of the
+ *   F1 ADR-0003 violation.
+ *
+ *   This module is the single home of that identity. Both engines import it; no
+ *   consumer keys edges by a bare `bodyHash`. The Phase-1 fitness check
+ *   (`no-bodyhash-keying-outside-identity`) forbids re-deriving an owner-keyed
+ *   edge map anywhere else, so the drift cannot recur.
+ *
+ * Pure: no fs, no engine state — both engines and the equivalence harness import
+ * the same helpers.
+ */
+import { ownerEdgeKey } from '../../owner-key.js';
+export { ownerEdgeKey } from '../../owner-key.js';
+/**
+ * Bucket a flat list of edge-bearing items into a `Map<ownerEdgeKey, CallEdge[]>`,
+ * keyed via {@link ownerEdgeKey} (NOT by `bodyHash` alone). `keyParts` extracts
+ * the owning occurrence's `(bodyHash, filePath)` from each item; `edgeOf`
+ * extracts the edge. Append-order within a bucket is preserved (callers sort
+ * downstream for determinism). The canonical owner-keyed bucket: every consumer
+ * routes through this instead of re-deriving an owner key inline.
+ */
+export function bucketEdgesByOwner(items, keyParts, edgeOf) {
+    const byOwner = new Map();
+    for (const item of items) {
+        const { bodyHash, filePath } = keyParts(item);
+        const key = ownerEdgeKey(bodyHash, filePath);
+        const bucket = byOwner.get(key);
+        if (bucket)
+            bucket.push(edgeOf(item));
+        else
+            byOwner.set(key, [edgeOf(item)]);
+    }
+    return byOwner;
+}
+/**
+ * Stitch recovered edges onto each occurrence, keyed by
+ * `ownerEdgeKey(o.bodyHash, o.filePath)` so ONLY the owning occurrence receives
+ * its edges (body-twins in different files never smear). `combine` decides how an
+ * occurrence's existing `calls` and its recovered edges merge (e.g. replace,
+ * concatenate, or drop-placeholder-then-concat) and returns the new occurrence —
+ * keeping the keying in one place while leaving the per-engine merge policy to
+ * the caller. An occurrence with no recovered edges is returned unchanged.
+ */
+export function stitchEdgesByOwner(functions, edgesByOwnerKey, combine) {
+    const out = Object.create(null);
+    for (const [name, occs] of Object.entries(functions)) {
+        if (!occs)
+            continue;
+        out[name] = occs.map((o) => {
+            const recovered = edgesByOwnerKey.get(ownerEdgeKey(o.bodyHash, o.filePath));
+            return recovered === undefined || recovered.length === 0 ? o : combine(o, recovered);
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=edge-identity.js.map

package/dist/cli/orchestrate/edge-identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-identity.js","sourceRoot":"","sources":["../../../src/cli/orchestrate/edge-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIlD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAkB,EAClB,QAA+E,EAC/E,MAA6B;IAE7B,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC9C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;QAC9C,MAAM,GAAG,GAAG,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,MAAM;YAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;;YACjC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAAkE,EAClE,eAAyD,EACzD,OAAwF;IAExF,MAAM,GAAG,GAAkD,MAAM,CAAC,MAAM,CAAC,IAAI,CAG5E,CAAC;IACF,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QACrD,IAAI,CAAC,IAAI;YAAE,SAAS;QACpB,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACzB,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC5E,OAAO,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QACvF,CAAC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/cli/orchestrate/equivalence-check.d.ts

@@ -0,0 +1,227 @@
+/**
+ * REAL-REPO equivalence guardrail — the dogfood gate that catches an
+ * edge-resolution regression on a genuine multi-package TypeScript monorepo.
+ *
+ * WHY THIS EXISTS (the gap it closes):
+ *   The in-test equivalence gate (`__tests__/equivalence*.test.ts`) builds BOTH
+ *   engines through a SYNTHETIC text adapter that reuses the production
+ *   cross-package helpers (`resolveSpecifierToPackage` + `buildExportIndex`), so
+ *   the two engines "agree by construction" — it structurally CANNOT model the
+ *   real TypeScript `dist/*.d.ts` resolution where the
+ *   exact-engine-under-resolution bug actually lived. That is false confidence.
+ *
+ *   This guardrail instead builds BOTH catalogs on a REAL repo (default: this
+ *   one) with the REAL TypeScript adapter — so workspace `@scope/pkg` imports
+ *   resolve through Node16 to built `dist/*.d.ts`, exactly the divergence class
+ *   the bug occupied. It then diffs (exact ≡ sharded) via `diffCatalogs` and
+ *   classifies the residual by OWNER FILE:
+ *
+ *     - functionsOnly{A,B} MUST be 0 (the function sets are byte-equal
+ *       post-reconciliation) — any non-zero is a hard FAILURE.
+ *     - TEST/FIXTURE-owned edge divergences are benign (the graph rules skip
+ *       test files, so they are gate-invisible) — counted separately, never
+ *       gated.
+ *     - PRODUCTION edge divergences are the meaningful signal, classified by
+ *       DIRECTION on the unified model (ADR-0033): phantom (sharded-only),
+ *       decline (exact-only), conflict (both resolve to different targets). Each
+ *       direction is compared against its COMMITTED FLOOR; the guardrail FAILS
+ *       when any direction EXCEEDS its floor (a NEW divergence on the unified
+ *       model) and PASSES (with a tighten hint) on a decrease. Per-direction
+ *       gating so a fixed conflict can't mask a new phantom. A ratchet, mirroring
+ *       the repo's net-new SARIF philosophy. (The both-engine-DECLINE blind spot
+ *       this differential cannot see is guarded by the pinned-corpus completeness
+ *       floor in `resolution-completeness-floor.test.ts`.)
+ *
+ * Engine-layer + language-agnostic: it drives `runGraph` (exact) and
+ * `runShardedGraph` (sharded) through the same shard-resolution the production
+ * `graph` command uses (`resolveShardsForCwd`), so there is ONE resolver, never
+ * a drifting copy. Cold + no-cache on both sides (a fresh oracle every run).
+ */
+import type { EdgeDifference } from './cross-shard-resolve.js';
+import type { Shard } from './shard-model.js';
+import type { Catalog, ResolutionMode } from '../../types.js';
+/** A function-set divergence: one engine discovered a function the other did not. */
+export type FunctionSetBreach = readonly string[];
+/**
+ * Owner-file classification of an edge divergence. Matches the paths the graph
+ * rules skip (so the divergence is gate-invisible): any `__tests__/` or
+ * `__fixtures__/` tree segment, or a `*.test.*` / `*.spec.*` filename. Operates
+ * on project-relative catalog `filePath`s, posix-normalized.
+ */
+export declare function isTestOrFixturePath(filePath: string): boolean;
+/**
+ * The DIRECTION of a resolved-edge divergence — which engine resolved the site,
+ * once both engines run ONE model (Phase 3 convergence, ADR-0033). Direction no
+ * longer encodes "wrongness" (neither engine is the oracle: a sharded-only edge
+ * is frequently a REAL edge the single-program type checker under-resolved, e.g.
+ * `scope.graph?.rules.getAll()` through an optional chain). It is a DIAGNOSTIC
+ * label — "which bound is insufficient" — and each direction is ratcheted to its
+ * measured floor so any NEW divergence on the unified model fails, with a
+ * documented residual class per direction.
+ *
+ *   - `phantom`  — sharded resolved, exact declined  (exact-only gap)
+ *   - `decline`  — exact resolved, sharded declined  (sharded-only gap)
+ *   - `conflict` — BOTH resolved, to DIFFERENT targets (a real disambiguation
+ *                  bug: at least one engine picked the wrong same-name occurrence)
+ *
+ * `conflict` is the load-bearing class — both engines confidently disagree, so
+ * one is provably wrong. `phantom`/`decline` are one-sided gaps where the other
+ * engine simply has more/less reach.
+ */
+export type DivergenceDirection = 'phantom' | 'decline' | 'conflict';
+/** Classify a resolved divergence by which engine(s) resolved it. */
+export declare function divergenceDirection(d: EdgeDifference): DivergenceDirection;
+/**
+ * A committed budget: the per-direction ratchet floors for production resolved-
+ * edge divergences on the unified model (ADR-0033). Replaces the single
+ * `productionResolvedEdgeDivergences` total: after convergence, a flat total can
+ * hide a direction flip (a fixed conflict masking a new phantom). Each direction
+ * is gated independently; any count EXCEEDING its floor FAILS, a decrease passes
+ * with a tighten hint, equal passes.
+ */
+export interface EquivalenceBudget {
+    /** Accepted sharded-only (exact-declined) production divergences. */
+    readonly phantomDivergences: number;
+    /** Accepted exact-only (sharded-declined) production divergences. */
+    readonly declineDivergences: number;
+    /** Accepted both-resolved-differently production divergences (the same-name
+     *  disambiguation class — a real bug, tracked for follow-up). */
+    readonly conflictDivergences: number;
+    /**
+     * Accepted SCC membership divergences. SCCs are a DOWNSTREAM consequence of the
+     * resolved-edge residual (a differing cross-package edge can reshape a
+     * component), so on a repo with a non-zero edge residual SCC differences are
+     * expected and budgeted, not hard-failed. Same ratchet semantics.
+     */
+    readonly sccDivergences: number;
+    /**
+     * Optional human note recorded alongside the numbers (what each residual class
+     * is). Ignored by the comparison.
+     */
+    readonly note?: string;
+}
+/** The classified outcome of one equivalence run. */
+export interface EquivalenceReport {
+    /** functionsOnlyInA (exact-only) — MUST be empty (a hard failure if not). */
+    readonly functionsOnlyInExact: FunctionSetBreach;
+    /** functionsOnlyInB (sharded-only) — MUST be empty (a hard failure if not). */
+    readonly functionsOnlyInSharded: FunctionSetBreach;
+    /** SCC membership divergences (budgeted — a downstream consequence of edges). */
+    readonly sccDifferences: readonly string[];
+    /** Every differing edge key, owner-attributed (resolved + structural). */
+    readonly allEdgeDifferences: readonly EdgeDifference[];
+    /**
+     * RESOLVED-edge divergences owned by a PRODUCTION file — the gated signal
+     * (dropped/added real edges in non-test code). The directional partitions
+     * below sum to this.
+     */
+    readonly productionResolvedDifferences: readonly EdgeDifference[];
+    /** Production divergences where SHARDED resolved but EXACT declined. */
+    readonly productionPhantom: readonly EdgeDifference[];
+    /** Production divergences where EXACT resolved but SHARDED declined. */
+    readonly productionDecline: readonly EdgeDifference[];
+    /** Production divergences where BOTH resolved, to DIFFERENT targets. */
+    readonly productionConflict: readonly EdgeDifference[];
+    /**
+     * RESOLVED-edge divergences owned by a TEST/FIXTURE file — benign
+     * (gate-invisible: the graph rules skip test files). Reported, not gated.
+     */
+    readonly testResolvedDifferences: readonly EdgeDifference[];
+    /**
+     * STRUCTURAL divergences — a call site recorded as UNRESOLVED (`to: []`) on one
+     * engine and absent on the other. Neither resolved a target, so this does not
+     * change the resolved call graph; reported for transparency, never gated.
+     */
+    readonly structuralDifferences: readonly EdgeDifference[];
+    /** Catalog function counts, for the report header. */
+    readonly exactFunctionCount: number;
+    readonly shardedFunctionCount: number;
+}
+/** Build the exact + sharded catalogs on `cwd`, diff, and classify by owner file. */
+export interface BuildEquivalenceInput {
+    /** Target repo root (default: process.cwd()). */
+    readonly cwd: string;
+    /**
+     * The resolved shard set for `cwd` (≥2 shards). Resolved by the caller via the
+     * production `resolveShardsForCwd` so the guardrail shards the project the
+     * SAME way a real `graph` run does. An empty/≤1 set is a usage error (the repo
+     * must be shardable for the comparison to be meaningful).
+     */
+    readonly shards: readonly Shard[];
+    /** CLI entry script for spawning shard workers (`process.argv[1]`). */
+    readonly cliScript: string;
+    /** Exact single-program build (the oracle). */
+    readonly buildExact: (cwd: string) => Promise<Catalog | null>;
+    /** Sharded build. */
+    readonly buildSharded: (input: {
+        shards: readonly Shard[];
+        projectRoot: string;
+        cliScript: string;
+        resolutionMode: ResolutionMode;
+    }) => Promise<Catalog>;
+}
+/**
+ * Run the real-repo equivalence comparison and classify the residual. Diffs as
+ * `diffCatalogs(exact, sharded)` — so `functionsOnlyInA` is exact-only and
+ * `functionsOnlyInB` is sharded-only — then partitions the edge differences by
+ * owner file (production vs test/fixture).
+ *
+ * @throws {Error} If the exact (single-program) build produces no catalog — the
+ *   target repo must contain analyzable source for the comparison to be meaningful.
+ */
+export declare function buildEquivalenceReport(input: BuildEquivalenceInput): Promise<EquivalenceReport>;
+/**
+ * Resolved CROSS-PACKAGE edge count in a catalog — the completeness metric for
+ * the pinned-corpus floor (ADR-0033). A `crossShard` edge with a non-empty
+ * target set is a recovered cross-package call; declined boundary calls are
+ * PRUNED from the catalog (they leave only the intra placeholder), so this count
+ * IS the resolved numerator. On a PINNED corpus (fixed call-site denominator) a
+ * non-decreasing count is equivalent to a non-decreasing resolution RATE — it
+ * catches a both-engine completeness regression (one that drops edges in BOTH
+ * engines, so the differential gate above stays silent).
+ */
+export declare function countResolvedCrossPackageEdges(catalog: Catalog): number;
+/** The verdict of comparing a report against a budget. */
+export interface EquivalenceVerdict {
+    /** True ⇒ the guardrail FAILS (non-zero exit). */
+    readonly failed: boolean;
+    /** True ⇒ a function-set breach (a hard failure regardless of budget). */
+    readonly functionSetBreached: boolean;
+    /** Observed sharded-only (exact-declined) production divergence count. */
+    readonly phantomCount: number;
+    /** Observed exact-only (sharded-declined) production divergence count. */
+    readonly declineCount: number;
+    /** Observed both-resolved-differently production divergence count. */
+    readonly conflictCount: number;
+    /** Total observed production resolved-edge divergence count (sum of the three). */
+    readonly productionCount: number;
+    /** Observed SCC divergence count. */
+    readonly sccCount: number;
+    /** The budget's accepted SCC count. */
+    readonly sccBudget: number;
+    /** Human-readable lines for the CLI output (always populated). */
+    readonly lines: readonly string[];
+}
+/**
+ * Compare a report against the committed budget and produce the gate verdict +
+ * human-readable lines. After Phase 3 convergence (ADR-0033) the gate is the
+ * DIRECTIONAL soundness invariant: any NEW divergence on the unified model fails,
+ * each direction ratcheted to its measured floor.
+ *
+ *   - Any function-set breach (functionsOnly{Exact,Sharded}) ⇒ HARD FAIL: the
+ *     function SET must be byte-equal post-reconciliation (a discovery/merge
+ *     regression, never an edge gap).
+ *   - phantom / decline / conflict production divergences each > their floor ⇒
+ *     FAIL, printing the offending owner edges for the breached direction(s).
+ *     Gating per-direction (not a flat total) so a fixed conflict can't mask a
+ *     new phantom.
+ *   - SCC divergences > budget ⇒ FAIL (a downstream consequence of the edge
+ *     residual — budgeted, not hard-failed, since the real-repo residual is
+ *     non-zero).
+ *   - any metric < its floor ⇒ PASS, with a hint to tighten that number.
+ *   - == floor ⇒ PASS.
+ *
+ * Structural (unresolved-vs-absent) divergences are reported but never gated.
+ */
+export declare function judgeEquivalence(report: EquivalenceReport, budget: EquivalenceBudget): EquivalenceVerdict;
+//# sourceMappingURL=equivalence-check.d.ts.map

package/dist/cli/orchestrate/equivalence-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equivalence-check.d.ts","sourceRoot":"","sources":["../../../src/cli/orchestrate/equivalence-check.ts"],"names":[],"mappings":"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"}

package/dist/cli/orchestrate/equivalence-check.js

@@ -0,0 +1,264 @@
+/**
+ * REAL-REPO equivalence guardrail — the dogfood gate that catches an
+ * edge-resolution regression on a genuine multi-package TypeScript monorepo.
+ *
+ * WHY THIS EXISTS (the gap it closes):
+ *   The in-test equivalence gate (`__tests__/equivalence*.test.ts`) builds BOTH
+ *   engines through a SYNTHETIC text adapter that reuses the production
+ *   cross-package helpers (`resolveSpecifierToPackage` + `buildExportIndex`), so
+ *   the two engines "agree by construction" — it structurally CANNOT model the
+ *   real TypeScript `dist/*.d.ts` resolution where the
+ *   exact-engine-under-resolution bug actually lived. That is false confidence.
+ *
+ *   This guardrail instead builds BOTH catalogs on a REAL repo (default: this
+ *   one) with the REAL TypeScript adapter — so workspace `@scope/pkg` imports
+ *   resolve through Node16 to built `dist/*.d.ts`, exactly the divergence class
+ *   the bug occupied. It then diffs (exact ≡ sharded) via `diffCatalogs` and
+ *   classifies the residual by OWNER FILE:
+ *
+ *     - functionsOnly{A,B} MUST be 0 (the function sets are byte-equal
+ *       post-reconciliation) — any non-zero is a hard FAILURE.
+ *     - TEST/FIXTURE-owned edge divergences are benign (the graph rules skip
+ *       test files, so they are gate-invisible) — counted separately, never
+ *       gated.
+ *     - PRODUCTION edge divergences are the meaningful signal, classified by
+ *       DIRECTION on the unified model (ADR-0033): phantom (sharded-only),
+ *       decline (exact-only), conflict (both resolve to different targets). Each
+ *       direction is compared against its COMMITTED FLOOR; the guardrail FAILS
+ *       when any direction EXCEEDS its floor (a NEW divergence on the unified
+ *       model) and PASSES (with a tighten hint) on a decrease. Per-direction
+ *       gating so a fixed conflict can't mask a new phantom. A ratchet, mirroring
+ *       the repo's net-new SARIF philosophy. (The both-engine-DECLINE blind spot
+ *       this differential cannot see is guarded by the pinned-corpus completeness
+ *       floor in `resolution-completeness-floor.test.ts`.)
+ *
+ * Engine-layer + language-agnostic: it drives `runGraph` (exact) and
+ * `runShardedGraph` (sharded) through the same shard-resolution the production
+ * `graph` command uses (`resolveShardsForCwd`), so there is ONE resolver, never
+ * a drifting copy. Cold + no-cache on both sides (a fresh oracle every run).
+ */
+import { diffCatalogs } from './cross-shard-resolve.js';
+/**
+ * Owner-file classification of an edge divergence. Matches the paths the graph
+ * rules skip (so the divergence is gate-invisible): any `__tests__/` or
+ * `__fixtures__/` tree segment, or a `*.test.*` / `*.spec.*` filename. Operates
+ * on project-relative catalog `filePath`s, posix-normalized.
+ */
+export function isTestOrFixturePath(filePath) {
+    const p = filePath.replaceAll('\\', '/');
+    return (p.includes('/__tests__/') ||
+        p.startsWith('__tests__/') ||
+        p.includes('/__fixtures__/') ||
+        p.startsWith('__fixtures__/') ||
+        /(?:^|\/)[^/]+\.(?:test|spec)\.[A-Za-z0-9]+$/.test(p));
+}
+/**
+ * A RESOLVED-edge divergence is the meaningful signal: a call site where the two
+ * engines disagree on a NON-EMPTY resolved target set (one resolved it, the
+ * other didn't, or they resolved it differently). A call site that is UNRESOLVED
+ * (`to: []`) on one side and simply absent on the other contributes nothing to
+ * the resolved call graph — both engines agree there is no target — so it is
+ * NOT a resolved divergence (it is reported separately as a structural/
+ * unresolved divergence, not gated). This is what isolates the dropped/added
+ * REAL cross-package edges the guardrail exists to catch.
+ */
+function isResolvedDivergence(d) {
+    return d.toA !== d.toB && (d.toA.length > 0 || d.toB.length > 0);
+}
+/** Classify a resolved divergence by which engine(s) resolved it. */
+export function divergenceDirection(d) {
+    if (d.toA.length === 0)
+        return 'phantom'; // exact empty, sharded resolved
+    if (d.toB.length === 0)
+        return 'decline'; // sharded empty, exact resolved
+    return 'conflict'; // both resolved, different targets
+}
+function functionCount(catalog) {
+    let n = 0;
+    for (const occs of Object.values(catalog.functions))
+        n += occs?.length ?? 0;
+    return n;
+}
+/**
+ * Run the real-repo equivalence comparison and classify the residual. Diffs as
+ * `diffCatalogs(exact, sharded)` — so `functionsOnlyInA` is exact-only and
+ * `functionsOnlyInB` is sharded-only — then partitions the edge differences by
+ * owner file (production vs test/fixture).
+ *
+ * @throws {Error} If the exact (single-program) build produces no catalog — the
+ *   target repo must contain analyzable source for the comparison to be meaningful.
+ */
+export async function buildEquivalenceReport(input) {
+    const exact = await input.buildExact(input.cwd);
+    if (exact === null) {
+        throw new Error('Equivalence check: the exact (single-program) build produced no catalog ' +
+            '(no parseable input). The target repo must contain analyzable source.');
+    }
+    const sharded = await input.buildSharded({
+        shards: input.shards,
+        projectRoot: input.cwd,
+        cliScript: input.cliScript,
+        resolutionMode: 'exact',
+    });
+    const eq = diffCatalogs(exact, sharded);
+    const resolved = eq.edgeDifferences.filter(isResolvedDivergence);
+    const structuralDifferences = eq.edgeDifferences.filter((d) => !isResolvedDivergence(d));
+    const productionResolvedDifferences = resolved.filter((d) => !isTestOrFixturePath(d.ownerFilePath));
+    const testResolvedDifferences = resolved.filter((d) => isTestOrFixturePath(d.ownerFilePath));
+    const byDirection = (dir) => productionResolvedDifferences.filter((d) => divergenceDirection(d) === dir);
+    return {
+        functionsOnlyInExact: eq.functionsOnlyInA,
+        functionsOnlyInSharded: eq.functionsOnlyInB,
+        sccDifferences: eq.sccDifferences,
+        allEdgeDifferences: eq.edgeDifferences,
+        productionResolvedDifferences,
+        productionPhantom: byDirection('phantom'),
+        productionDecline: byDirection('decline'),
+        productionConflict: byDirection('conflict'),
+        testResolvedDifferences,
+        structuralDifferences,
+        exactFunctionCount: functionCount(exact),
+        shardedFunctionCount: functionCount(sharded),
+    };
+}
+/**
+ * Resolved CROSS-PACKAGE edge count in a catalog — the completeness metric for
+ * the pinned-corpus floor (ADR-0033). A `crossShard` edge with a non-empty
+ * target set is a recovered cross-package call; declined boundary calls are
+ * PRUNED from the catalog (they leave only the intra placeholder), so this count
+ * IS the resolved numerator. On a PINNED corpus (fixed call-site denominator) a
+ * non-decreasing count is equivalent to a non-decreasing resolution RATE — it
+ * catches a both-engine completeness regression (one that drops edges in BOTH
+ * engines, so the differential gate above stays silent).
+ */
+export function countResolvedCrossPackageEdges(catalog) {
+    let n = 0;
+    for (const occs of Object.values(catalog.functions)) {
+        for (const o of occs ?? []) {
+            for (const e of o.calls) {
+                if (e.crossShard === true && e.to.length > 0)
+                    n++;
+            }
+        }
+    }
+    return n;
+}
+/**
+ * Compare a report against the committed budget and produce the gate verdict +
+ * human-readable lines. After Phase 3 convergence (ADR-0033) the gate is the
+ * DIRECTIONAL soundness invariant: any NEW divergence on the unified model fails,
+ * each direction ratcheted to its measured floor.
+ *
+ *   - Any function-set breach (functionsOnly{Exact,Sharded}) ⇒ HARD FAIL: the
+ *     function SET must be byte-equal post-reconciliation (a discovery/merge
+ *     regression, never an edge gap).
+ *   - phantom / decline / conflict production divergences each > their floor ⇒
+ *     FAIL, printing the offending owner edges for the breached direction(s).
+ *     Gating per-direction (not a flat total) so a fixed conflict can't mask a
+ *     new phantom.
+ *   - SCC divergences > budget ⇒ FAIL (a downstream consequence of the edge
+ *     residual — budgeted, not hard-failed, since the real-repo residual is
+ *     non-zero).
+ *   - any metric < its floor ⇒ PASS, with a hint to tighten that number.
+ *   - == floor ⇒ PASS.
+ *
+ * Structural (unresolved-vs-absent) divergences are reported but never gated.
+ */
+export function judgeEquivalence(report, budget) {
+    const lines = [];
+    const phantomCount = report.productionPhantom.length;
+    const declineCount = report.productionDecline.length;
+    const conflictCount = report.productionConflict.length;
+    const productionCount = report.productionResolvedDifferences.length;
+    const sccCount = report.sccDifferences.length;
+    const sccBudget = budget.sccDivergences;
+    const functionSetBreached = report.functionsOnlyInExact.length > 0 || report.functionsOnlyInSharded.length > 0;
+    lines.push(`Graph engine equivalence (exact ≡ sharded) on the real repo:`, `  functions: exact=${String(report.exactFunctionCount)} sharded=${String(report.shardedFunctionCount)}`, `  functionsOnlyInExact=${String(report.functionsOnlyInExact.length)} ` +
+        `functionsOnlyInSharded=${String(report.functionsOnlyInSharded.length)}`, `  production resolved-edge divergences (total=${String(productionCount)}) by direction:`, `    phantom  (sharded-only): ${String(phantomCount)} (budget ${String(budget.phantomDivergences)})`, `    decline  (exact-only):   ${String(declineCount)} (budget ${String(budget.declineDivergences)})`, `    conflict (both differ):  ${String(conflictCount)} (budget ${String(budget.conflictDivergences)})`, `  test/fixture resolved divergences: ${String(report.testResolvedDifferences.length)} (benign)`, `  scc divergences: ${String(sccCount)} (budget ${String(sccBudget)})`, `  structural (unresolved-vs-absent) divergences: ${String(report.structuralDifferences.length)} (informational)`);
+    if (functionSetBreached) {
+        lines.push(`  FAIL: function-set divergence — the two engines disagree on the FUNCTION SET.`, `        This MUST be 0 (a discovery/merge regression, not an edge gap).`);
+        appendSample(lines, 'exact-only function', report.functionsOnlyInExact);
+        appendSample(lines, 'sharded-only function', report.functionsOnlyInSharded);
+    }
+    const directions = [
+        {
+            label: 'phantom (sharded-only)',
+            key: 'phantomDivergences',
+            count: phantomCount,
+            budget: budget.phantomDivergences,
+            diffs: report.productionPhantom,
+        },
+        {
+            label: 'decline (exact-only)',
+            key: 'declineDivergences',
+            count: declineCount,
+            budget: budget.declineDivergences,
+            diffs: report.productionDecline,
+        },
+        {
+            label: 'conflict (both differ)',
+            key: 'conflictDivergences',
+            count: conflictCount,
+            budget: budget.conflictDivergences,
+            diffs: report.productionConflict,
+        },
+    ];
+    let directionBreached = false;
+    for (const d of directions) {
+        judgeMetric(lines, {
+            label: `${d.label} divergence`,
+            key: d.key,
+            count: d.count,
+            budget: d.budget,
+        });
+        if (d.count > d.budget) {
+            directionBreached = true;
+            lines.push(`    NEW ${d.label} edges (owner file:line  exact=[..] sharded=[..]):`);
+            for (const diff of d.diffs) {
+                lines.push(`      ${diff.ownerFilePath}:${String(diff.line)}:${String(diff.column)}  ` +
+                    `exact=[${diff.toA}] sharded=[${diff.toB}]`);
+            }
+        }
+    }
+    const sccOverBudget = sccCount > sccBudget;
+    judgeMetric(lines, {
+        label: 'SCC divergence',
+        key: 'sccDivergences',
+        count: sccCount,
+        budget: sccBudget,
+    });
+    const failed = functionSetBreached || directionBreached || sccOverBudget;
+    lines.push(failed ? `  RESULT: FAIL` : `  RESULT: PASS`);
+    return {
+        failed,
+        functionSetBreached,
+        phantomCount,
+        declineCount,
+        conflictCount,
+        productionCount,
+        sccCount,
+        sccBudget,
+        lines,
+    };
+}
+/** Emit the PASS/FAIL/tighten line for one budgeted metric. */
+function judgeMetric(lines, m) {
+    if (m.count > m.budget) {
+        lines.push(`  FAIL: ${m.label} ${String(m.count)} EXCEEDS budget ${String(m.budget)} (+${String(m.count - m.budget)}).`);
+    }
+    else if (m.count < m.budget) {
+        lines.push(`  PASS: ${m.label} ${String(m.count)} is BELOW budget ${String(m.budget)}; ` +
+            `tighten the ratchet: set ${m.key}=${String(m.count)} in the budget JSON.`);
+    }
+    else {
+        lines.push(`  PASS: ${m.label} matches budget (${String(m.budget)}).`);
+    }
+}
+/** Append up to 5 sample identities of a breach list (keeps output bounded). */
+function appendSample(lines, label, ids) {
+    for (const id of ids.slice(0, 5))
+        lines.push(`    ${label}: ${id}`);
+    if (ids.length > 5)
+        lines.push(`    … and ${String(ids.length - 5)} more ${label}(s)`);
+}
+//# sourceMappingURL=equivalence-check.js.map

package/dist/cli/orchestrate/equivalence-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equivalence-check.js","sourceRoot":"","sources":["../../../src/cli/orchestrate/equivalence-check.ts"],"names":[],"mappings":"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"}

package/dist/cli/orchestrate/exact-boundary-recovery.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Exact-engine boundary recovery (Phase 3, Option A — "exact = the 1-shard case").
+ *
+ * The single-program (exact) catalog IS the whole/merged catalog, so the cross-
+ * package call sites its type-checker-driven inline pass captures inconsistently
+ * (it only fires where `getSymbolAtLocation` succeeds and the reference kind
+ * dispatches) are recovered by running the SAME post-merge linker the sharded
+ * engine runs — `resolveCrossBoundaryCalls` — over the syntactic boundary calls
+ * the exact build emitted. The extractor already skips sites resolved inline, so
+ * a recovered edge never double-counts. This is what converges the two engines.
+ */
+import type { Catalog, CrossBoundaryCall } from '../../types.js';
+/**
+ * Link the syntactic boundary calls the exact build emitted against its own
+ * (whole-program) catalog via the shared cross-shard linker. No-op when nothing
+ * was emitted (e.g. an incremental rebuild that touched no cross-package site).
+ */
+export declare function recoverExactBoundaryEdges(built: {
+    readonly catalog: Catalog;
+    readonly boundaryCalls?: readonly CrossBoundaryCall[];
+}, files: readonly string[], projectRoot: string): Catalog;
+/**
+ * The distinct workspace package ROOTS (absolute) the source files belong to —
+ * each file's nearest ancestor dir containing a `package.json`, up to the project
+ * root. Feeds `buildPackageManifestIndexFromRoots` so the exact engine resolves a
+ * `@scope/pkg` specifier to its package group exactly as the sharded engine does
+ * (which derives the same set from its `Shard[]`). Memoized per directory.
+ */
+export declare function derivePackageRoots(files: readonly string[], projectRoot: string): string[];
+/** Nearest ancestor dir of `startDir` (inclusive) containing a `package.json`,
+ *  up to `projectRoot`; `null` if none. */
+export declare function findPackageRoot(startDir: string, projectRoot: string): string | null;
+//# sourceMappingURL=exact-boundary-recovery.d.ts.map

package/dist/cli/orchestrate/exact-boundary-recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exact-boundary-recovery.d.ts","sourceRoot":"","sources":["../../../src/cli/orchestrate/exact-boundary-recovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE;IACL,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACvD,EACD,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAOT;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAa1F;AAED;2CAC2C;AAC3C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQpF"}