@descryy/core 0.1.0

package/dist/query/root-cause-score.d.ts

@@ -0,0 +1,218 @@
+/**
+ * `RootCauseScore` — architecture §18.3a, the deterministic ranking half.
+ *
+ * ```
+ * RootCauseScore = RuntimeEvidence + GraphDistance + ChangeCoupling + IncidentCorrelation
+ * ```
+ *
+ * §18.3 establishes why ranking exists at all: traversal alone returns a
+ * *path*, not a culprit. A five-hop chain has five candidate locations, and
+ * presenting all five is diagnostically equivalent to presenting none.
+ *
+ * ## Reuses three existing queries — does not re-derive them
+ *
+ * `documents/decisions-inbox/NOTE-4-correlation-graph-integration-prep.md`
+ * §1 maps three of the four terms onto queries this package already has,
+ * checked line by line against `queries.ts` rather than assumed:
+ *
+ * | Term | Query | Role here |
+ * | --- | --- | --- |
+ * | `GraphDistance` | `weightedBfs` (`impactOf`'s own underlying primitive, called directly — see below) | `direction: "out"`, walking `CALLS`/`USES_API`/`SERVES_API` from the failure point toward the deep implementation — §18.3's own worked example, and its own hop×confidence-decayed `score` is used as-is. |
+ * | `ChangeCoupling` | `changesWith` | Was this candidate, or a co-change partner of it, in the current diff. |
+ * | `IncidentCorrelation` | `rootCauseSearch` | Structural half only — inherits that query's own disclosed gap (no vector store, §8.2) unchanged. |
+ * | `RuntimeEvidence` | **none, and none should exist here** | See below. |
+ *
+ * **`weightedBfs` directly, not `impactOf`** — a deliberate, narrow deviation
+ * from "reuses, does not re-derive." `RankedRootCauseCandidate.path` (the
+ * real hop-by-hop `GraphPathHop[]` `Finding.graphPath` needs,
+ * `documents/decisions-inbox/DEC-D-NEXT-graph-path-hop-reconstruction.md`,
+ * `descry-desktop`) is reconstructed by walking `Reached.via`'s parent
+ * pointers back to the seed — the exact traversal that produced `depth`/
+ * `score`. `impactOf` discards `via` in its own `hydrate()` step before this
+ * module ever sees the result, so getting it means calling `weightedBfs`
+ * itself. The scoring math is not re-derived — `entry.score`/`entry.depth`
+ * are still `weightedBfs`'s own values, used as-is, same as before; only the
+ * thin hydrate-plus-note wrapper `impactOf` adds is now inlined here so the
+ * `via` chain survives.
+ *
+ * `RootCauseScore`'s own walk crosses the `SERVES_API` join the same way
+ * §18.3's example does: `SERVES_API` is stored route → endpoint
+ * (`queries.ts`'s own comment), so a plain `direction: "out"` walk reaches
+ * the endpoint from a caller's `USES_API` edge and stops — it never looks
+ * incoming at that one node to find the route serving it. `crossApiEndpoint`
+ * (DEC-138) is passed through for exactly this reason; without it, this
+ * module's own fixture (`InvoicePage → deleteInvoice → DELETE
+ * /invoice/:id`) would never reach `InvoiceController`/`InvoiceService` at
+ * all, and the architecture's own worked example would not walk. The join
+ * crossover means a hop's own `from`/`to` sometimes runs opposite the walk's
+ * direction (the route→endpoint edge is walked endpoint→controller) — `path`
+ * reports the edge exactly as stored, never flipped to look like a forward
+ * chain that was never actually walked that way; see `pathTo`'s own comment.
+ *
+ * ## `RuntimeEvidence` is a precondition, never a fourth addend — read this before changing anything
+ *
+ * NOTE-4 §5 settles this and `ai-layer-plan.md` §5 (G3) preserves it: a
+ * candidate with maximal `GraphDistance + ChangeCoupling + IncidentCorrelation`
+ * and zero `RuntimeEvidence` is a plausible guess ranked well, and it must
+ * **never** reach `confirmed` however the other three terms sum — because
+ * summing all four together *is* the failure mode where a well-ranked guess
+ * reads as an established fact. DEC-276 encodes the same rule one layer up
+ * as `E == 0 → unconfirmed`.
+ *
+ * So this module never computes `structuralScore + runtimeEvidence` — not
+ * as an internal step, not as a returned field, nowhere. Two design choices
+ * make this a **type constraint**, not just a documented convention (proven
+ * by a `@ts-expect-error` test in this module's test file, checked by
+ * `tsc`, not merely asserted at runtime):
+ *
+ * 1. `structuralScore: number` carries only `GraphDistance + ChangeCoupling
+ *    + IncidentCorrelation`. Nothing runtime-evidence-shaped is a term in
+ *    it, ever.
+ * 2. `namedByEvidence: readonly string[]` — the verbatim evidence
+ *    descriptions naming this exact candidate, supplied by the caller
+ *    (`descry-runtime`'s evidence-to-node resolution; NOTE-4 §2 is explicit
+ *    that no graph query for this term exists or should — it is not a
+ *    graph fact). A `string[]`, not a `number` or a boolean count:
+ *    `structuralScore + namedByEvidence` does not typecheck, so a caller
+ *    cannot casually fold it into the ranking arithmetic by accident. A
+ *    caller who really wants to misuse it has to write new code to do so —
+ *    this module supplies no field shaped like the thing G3 forbids
+ *    summing.
+ *
+ * §18.3a's own table still calls `RuntimeEvidence` *"the strongest
+ * signal"* — a node named directly in a backend log outranks one merely on
+ * the path. That is honored **as a sort key, not a score term**:
+ * `namedByEvidence`-non-empty candidates sort before every candidate
+ * without it, and only within each of those two groups does
+ * `structuralScore` decide. Categorical partitioning, never arithmetic
+ * combination — the distinction NOTE-4 §5 draws is preserved exactly.
+ *
+ * `RootCauseScore` the architecture names is therefore not a function this
+ * module returns as one number. It ranks; a gate above this layer (G3/G4,
+ * `descry-runtime`/the pipeline) decides what `namedByEvidence` and the
+ * finding's actual evidence bundle are allowed to promote — this module
+ * does not gate and does not categorise.
+ *
+ * ## The resolution caveat (§18.3)
+ *
+ * *"At R0/R1 the tracer will lose the trail at the first cross-file call
+ * and must say 'trace stopped here' rather than presenting a truncated
+ * chain as complete."* When the traversal's own resolution floor is R0/R1,
+ * a note says so in those words — in addition to, not instead of,
+ * `impactOf`'s own disclosure, which explains *why* (cross-file calls are
+ * not reliably resolved at that level).
+ *
+ * ## Weights are starting values, not measurements
+ *
+ * `CLAUDE.md`: *"Numbers in the docs are targets or starting values, not
+ * measurements."* `DEFAULT_ROOT_CAUSE_WEIGHTS` and `INCIDENT_SATURATION`
+ * below are exactly that — picked, not measured, gathered into one named
+ * block rather than left as literals in the arithmetic so the next reader
+ * can find and tune them without reading the function body.
+ */
+import type { EdgeType, GraphPathHop, IRNode, ResolutionLevel } from "@descryy/ir";
+import type { AdjacencyProvider } from "./provider.ts";
+import { type RootCauseMatch } from "./queries.ts";
+/** §18.3's own walk: from the failure point toward the deep implementation. */
+export declare const ROOT_CAUSE_TRACE_EDGE_TYPES: readonly EdgeType[];
+/**
+ * The three structural terms' multipliers. **Unmeasured starting values**
+ * (`CLAUDE.md`'s own rule) — tune from data, not intuition, once golden
+ * investigations (`ai-layer-plan.md` §9 layer 4) exist to tune against.
+ */
+export interface RootCauseWeights {
+    readonly graphDistance: number;
+    readonly changeCoupling: number;
+    readonly incidentCorrelation: number;
+}
+export declare const DEFAULT_ROOT_CAUSE_WEIGHTS: RootCauseWeights;
+/**
+ * How many correlated incidents saturate `IncidentCorrelation`'s raw 0–1
+ * contribution. Unmeasured, same rule as the weights above: a candidate
+ * with dozens of correlated incidents should not dominate the ranking
+ * arithmetically more than one with a handful, so the raw count is capped
+ * before it is weighted.
+ */
+export declare const INCIDENT_SATURATION = 3;
+/** Why a candidate's `ChangeCoupling` term is nonzero — a fact worth keeping, not just a number. */
+export type ChangeCouplingEvidence = {
+    readonly kind: "direct";
+} | {
+    readonly kind: "co-change";
+    readonly viaNodeId: string;
+    readonly support: number;
+    readonly confidence: number;
+};
+export interface RootCauseOptions {
+    readonly weights?: RootCauseWeights;
+    /** How many ranked candidates to return. Presenting every candidate is diagnostically equivalent to presenting none — §18.3a. */
+    readonly topN?: number;
+    readonly maxDepth?: number;
+    readonly budget?: number;
+    /** Node ids the current diff touches directly — `ChangeCoupling`'s "in the current diff" half. */
+    readonly changedIds?: ReadonlySet<string>;
+    /**
+     * Verbatim evidence descriptions, keyed by the exact node id they name
+     * directly — supplied by the caller, never computed here. See the module
+     * header: this is not a graph fact, and no query for it exists in this
+     * package.
+     */
+    readonly namedByEvidence?: ReadonlyMap<string, readonly string[]>;
+}
+export interface RankedRootCauseCandidate {
+    readonly node: IRNode;
+    /** Hops from the failure point along the traced walk. 0 at the failure point itself. */
+    readonly depth: number;
+    /**
+     * `GraphDistance + ChangeCoupling + IncidentCorrelation`, weighted.
+     * **Never** includes `RuntimeEvidence` — see the module header.
+     */
+    readonly structuralScore: number;
+    readonly changeCoupling: ChangeCouplingEvidence | null;
+    readonly correlatedIncidents: readonly RootCauseMatch[];
+    /**
+     * Verbatim evidence naming this exact candidate. Empty, never omitted,
+     * when none. A precondition for promotion elsewhere (NOTE-4 §5, G3,
+     * DEC-276) — never a term in `structuralScore`.
+     */
+    readonly namedByEvidence: readonly string[];
+    /** The candidate node's own resolution — a fact stored on it directly, not re-derived. */
+    readonly resolution: ResolutionLevel;
+    /**
+     * `true` when `depth === 0` — this candidate *is* the failure point, and
+     * `resolution` above is that single node's own fact, not the minimum over
+     * any traced hop. `DEC-NEXT-empty-graph-path-resolution-floor.md` ruled
+     * that a zero-hop path caps reliability at the same class as a
+     * genuinely-but-badly-resolved one, but the two are not the same claim —
+     * this field is what lets a caller (`reliabilityNote()`'s `emptyPath`
+     * parameter, `@descryy/ir`) say which one happened, rather than
+     * inferring it from `depth === 0` at every call site. Never `true` for a
+     * deeper candidate: at least one hop was traced to reach it, however
+     * poorly that hop resolved.
+     */
+    readonly emptyPath: boolean;
+    /**
+     * The real, walked hop-by-hop chain from the failure point to this
+     * candidate — `Finding.graphPath`'s own source. Empty exactly when
+     * `emptyPath` is `true`. Reconstructed from `weightedBfs`'s own `via`
+     * chain, not a second independent walk — see the module header.
+     */
+    readonly path: readonly GraphPathHop[];
+}
+export interface RootCauseRanking {
+    /** Capped at `topN` (or fewer, if there simply weren't more candidates). */
+    readonly ranked: readonly RankedRootCauseCandidate[];
+    /** The honest denominator — every candidate the walk reached, before the `topN` cap. */
+    readonly candidateCount: number;
+    /** True when the walk's own budget stopped it short, or when `topN` dropped candidates. */
+    readonly truncated: boolean;
+    readonly notes: readonly string[];
+}
+/**
+ * Rank the candidates reachable from `failurePoint` by the three structural
+ * terms of `RootCauseScore` (architecture §18.3a). See the module header
+ * for why `RuntimeEvidence` is deliberately absent from the arithmetic and
+ * present only as `namedByEvidence`, a categorical sort key.
+ */
+export declare function rankRootCause(provider: AdjacencyProvider, failurePoint: string, options?: RootCauseOptions): RootCauseRanking;
+//# sourceMappingURL=root-cause-score.d.ts.map

package/dist/query/root-cause-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-cause-score.d.ts","sourceRoot":"","sources":["../../src/query/root-cause-score.ts"],"names":[],"mappings":"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"}

package/dist/query/root-cause-score.js

@@ -0,0 +1,251 @@
+/**
+ * `RootCauseScore` — architecture §18.3a, the deterministic ranking half.
+ *
+ * ```
+ * RootCauseScore = RuntimeEvidence + GraphDistance + ChangeCoupling + IncidentCorrelation
+ * ```
+ *
+ * §18.3 establishes why ranking exists at all: traversal alone returns a
+ * *path*, not a culprit. A five-hop chain has five candidate locations, and
+ * presenting all five is diagnostically equivalent to presenting none.
+ *
+ * ## Reuses three existing queries — does not re-derive them
+ *
+ * `documents/decisions-inbox/NOTE-4-correlation-graph-integration-prep.md`
+ * §1 maps three of the four terms onto queries this package already has,
+ * checked line by line against `queries.ts` rather than assumed:
+ *
+ * | Term | Query | Role here |
+ * | --- | --- | --- |
+ * | `GraphDistance` | `weightedBfs` (`impactOf`'s own underlying primitive, called directly — see below) | `direction: "out"`, walking `CALLS`/`USES_API`/`SERVES_API` from the failure point toward the deep implementation — §18.3's own worked example, and its own hop×confidence-decayed `score` is used as-is. |
+ * | `ChangeCoupling` | `changesWith` | Was this candidate, or a co-change partner of it, in the current diff. |
+ * | `IncidentCorrelation` | `rootCauseSearch` | Structural half only — inherits that query's own disclosed gap (no vector store, §8.2) unchanged. |
+ * | `RuntimeEvidence` | **none, and none should exist here** | See below. |
+ *
+ * **`weightedBfs` directly, not `impactOf`** — a deliberate, narrow deviation
+ * from "reuses, does not re-derive." `RankedRootCauseCandidate.path` (the
+ * real hop-by-hop `GraphPathHop[]` `Finding.graphPath` needs,
+ * `documents/decisions-inbox/DEC-D-NEXT-graph-path-hop-reconstruction.md`,
+ * `descry-desktop`) is reconstructed by walking `Reached.via`'s parent
+ * pointers back to the seed — the exact traversal that produced `depth`/
+ * `score`. `impactOf` discards `via` in its own `hydrate()` step before this
+ * module ever sees the result, so getting it means calling `weightedBfs`
+ * itself. The scoring math is not re-derived — `entry.score`/`entry.depth`
+ * are still `weightedBfs`'s own values, used as-is, same as before; only the
+ * thin hydrate-plus-note wrapper `impactOf` adds is now inlined here so the
+ * `via` chain survives.
+ *
+ * `RootCauseScore`'s own walk crosses the `SERVES_API` join the same way
+ * §18.3's example does: `SERVES_API` is stored route → endpoint
+ * (`queries.ts`'s own comment), so a plain `direction: "out"` walk reaches
+ * the endpoint from a caller's `USES_API` edge and stops — it never looks
+ * incoming at that one node to find the route serving it. `crossApiEndpoint`
+ * (DEC-138) is passed through for exactly this reason; without it, this
+ * module's own fixture (`InvoicePage → deleteInvoice → DELETE
+ * /invoice/:id`) would never reach `InvoiceController`/`InvoiceService` at
+ * all, and the architecture's own worked example would not walk. The join
+ * crossover means a hop's own `from`/`to` sometimes runs opposite the walk's
+ * direction (the route→endpoint edge is walked endpoint→controller) — `path`
+ * reports the edge exactly as stored, never flipped to look like a forward
+ * chain that was never actually walked that way; see `pathTo`'s own comment.
+ *
+ * ## `RuntimeEvidence` is a precondition, never a fourth addend — read this before changing anything
+ *
+ * NOTE-4 §5 settles this and `ai-layer-plan.md` §5 (G3) preserves it: a
+ * candidate with maximal `GraphDistance + ChangeCoupling + IncidentCorrelation`
+ * and zero `RuntimeEvidence` is a plausible guess ranked well, and it must
+ * **never** reach `confirmed` however the other three terms sum — because
+ * summing all four together *is* the failure mode where a well-ranked guess
+ * reads as an established fact. DEC-276 encodes the same rule one layer up
+ * as `E == 0 → unconfirmed`.
+ *
+ * So this module never computes `structuralScore + runtimeEvidence` — not
+ * as an internal step, not as a returned field, nowhere. Two design choices
+ * make this a **type constraint**, not just a documented convention (proven
+ * by a `@ts-expect-error` test in this module's test file, checked by
+ * `tsc`, not merely asserted at runtime):
+ *
+ * 1. `structuralScore: number` carries only `GraphDistance + ChangeCoupling
+ *    + IncidentCorrelation`. Nothing runtime-evidence-shaped is a term in
+ *    it, ever.
+ * 2. `namedByEvidence: readonly string[]` — the verbatim evidence
+ *    descriptions naming this exact candidate, supplied by the caller
+ *    (`descry-runtime`'s evidence-to-node resolution; NOTE-4 §2 is explicit
+ *    that no graph query for this term exists or should — it is not a
+ *    graph fact). A `string[]`, not a `number` or a boolean count:
+ *    `structuralScore + namedByEvidence` does not typecheck, so a caller
+ *    cannot casually fold it into the ranking arithmetic by accident. A
+ *    caller who really wants to misuse it has to write new code to do so —
+ *    this module supplies no field shaped like the thing G3 forbids
+ *    summing.
+ *
+ * §18.3a's own table still calls `RuntimeEvidence` *"the strongest
+ * signal"* — a node named directly in a backend log outranks one merely on
+ * the path. That is honored **as a sort key, not a score term**:
+ * `namedByEvidence`-non-empty candidates sort before every candidate
+ * without it, and only within each of those two groups does
+ * `structuralScore` decide. Categorical partitioning, never arithmetic
+ * combination — the distinction NOTE-4 §5 draws is preserved exactly.
+ *
+ * `RootCauseScore` the architecture names is therefore not a function this
+ * module returns as one number. It ranks; a gate above this layer (G3/G4,
+ * `descry-runtime`/the pipeline) decides what `namedByEvidence` and the
+ * finding's actual evidence bundle are allowed to promote — this module
+ * does not gate and does not categorise.
+ *
+ * ## The resolution caveat (§18.3)
+ *
+ * *"At R0/R1 the tracer will lose the trail at the first cross-file call
+ * and must say 'trace stopped here' rather than presenting a truncated
+ * chain as complete."* When the traversal's own resolution floor is R0/R1,
+ * a note says so in those words — in addition to, not instead of,
+ * `impactOf`'s own disclosure, which explains *why* (cross-file calls are
+ * not reliably resolved at that level).
+ *
+ * ## Weights are starting values, not measurements
+ *
+ * `CLAUDE.md`: *"Numbers in the docs are targets or starting values, not
+ * measurements."* `DEFAULT_ROOT_CAUSE_WEIGHTS` and `INCIDENT_SATURATION`
+ * below are exactly that — picked, not measured, gathered into one named
+ * block rather than left as literals in the arithmetic so the next reader
+ * can find and tune them without reading the function body.
+ */
+import { changesWith, rootCauseSearch } from "./queries.js";
+import { weightedBfs } from "./traverse.js";
+/** §18.3's own walk: from the failure point toward the deep implementation. */
+export const ROOT_CAUSE_TRACE_EDGE_TYPES = ["CALLS", "USES_API", "SERVES_API"];
+export const DEFAULT_ROOT_CAUSE_WEIGHTS = {
+    graphDistance: 1,
+    changeCoupling: 0.6,
+    incidentCorrelation: 0.8,
+};
+/**
+ * How many correlated incidents saturate `IncidentCorrelation`'s raw 0–1
+ * contribution. Unmeasured, same rule as the weights above: a candidate
+ * with dozens of correlated incidents should not dominate the ranking
+ * arithmetically more than one with a handful, so the raw count is capped
+ * before it is weighted.
+ */
+export const INCIDENT_SATURATION = 3;
+const DEFAULT_TOP_N = 5;
+function changeCouplingFor(provider, candidateId, changedIds) {
+    if (changedIds.has(candidateId))
+        return { kind: "direct" };
+    let best = null;
+    for (const co of changesWith(provider, candidateId).data) {
+        if (!changedIds.has(co.node.id))
+            continue;
+        if (best === null || (best.kind === "co-change" && co.confidence > best.confidence)) {
+            best = { kind: "co-change", viaNodeId: co.node.id, support: co.support, confidence: co.confidence };
+        }
+    }
+    return best;
+}
+function rawChangeCoupling(evidence) {
+    if (evidence === null)
+        return 0;
+    return evidence.kind === "direct" ? 1 : evidence.confidence;
+}
+/**
+ * Walks `reachedById`'s `via` parent pointers from `targetId` back to the
+ * seed (`via === null`), returning the hops in seed-to-target order.
+ *
+ * The edge stored at each step is reported exactly as `IREdge` has it
+ * (`from`/`to` never flipped) — at a `crossApiEndpoint` join the walk can
+ * arrive at a node via an edge whose *stored* direction runs the other way
+ * (the route→endpoint `SERVES_API` edge, walked endpoint→controller), and
+ * `next`/`via` in `neighbours()` already account for that: `entry.id`
+ * (the node this hop reached) equals exactly one of `via.from`/`via.to`, and
+ * the other end is always the parent — regardless of which direction the
+ * walk actually moved. That is the rule this function uses, rather than
+ * assuming `via.from` is always the parent.
+ */
+function pathTo(reachedById, targetId) {
+    const hops = [];
+    let currentId = targetId;
+    for (;;) {
+        const entry = reachedById.get(currentId);
+        if (entry === undefined || entry.via === null)
+            break;
+        const edge = entry.via;
+        hops.push({ from: edge.from, to: edge.to, edgeType: edge.type, resolution: edge.resolution });
+        currentId = edge.to === currentId ? edge.from : edge.to;
+    }
+    return hops.reverse();
+}
+/**
+ * Rank the candidates reachable from `failurePoint` by the three structural
+ * terms of `RootCauseScore` (architecture §18.3a). See the module header
+ * for why `RuntimeEvidence` is deliberately absent from the arithmetic and
+ * present only as `namedByEvidence`, a categorical sort key.
+ */
+export function rankRootCause(provider, failurePoint, options = {}) {
+    const weights = options.weights ?? DEFAULT_ROOT_CAUSE_WEIGHTS;
+    const topN = Math.max(0, Math.floor(options.topN ?? DEFAULT_TOP_N));
+    const changedIds = options.changedIds ?? new Set();
+    const namedByEvidence = options.namedByEvidence ?? new Map();
+    const outcome = weightedBfs(provider, [failurePoint], {
+        direction: "out",
+        types: ROOT_CAUSE_TRACE_EDGE_TYPES,
+        crossApiEndpoint: true,
+        ...(options.maxDepth === undefined ? {} : { maxDepth: options.maxDepth }),
+        ...(options.budget === undefined ? {} : { budget: options.budget }),
+    });
+    const reachedById = new Map(outcome.reached.map((r) => [r.id, r]));
+    const candidates = [];
+    for (const entry of outcome.reached) {
+        const node = provider.node(entry.id);
+        if (node === undefined)
+            continue; // hydrate: the provider no longer has this node
+        const coupling = changeCouplingFor(provider, node.id, changedIds);
+        const incidents = rootCauseSearch(provider, node.id).data;
+        const incidentCorrelationRaw = Math.min(1, incidents.length / INCIDENT_SATURATION);
+        const structuralScore = weights.graphDistance * entry.score + // weightedBfs's own hop x confidence decay — not re-derived
+            weights.changeCoupling * rawChangeCoupling(coupling) +
+            weights.incidentCorrelation * incidentCorrelationRaw;
+        candidates.push({
+            node,
+            depth: entry.depth,
+            structuralScore,
+            changeCoupling: coupling,
+            correlatedIncidents: incidents,
+            namedByEvidence: namedByEvidence.get(node.id) ?? [],
+            resolution: node.resolution,
+            emptyPath: entry.depth === 0,
+            path: pathTo(reachedById, node.id),
+        });
+    }
+    // §18.3a: RuntimeEvidence is "the strongest signal" for which candidate to
+    // present first — honored here as a categorical partition (named, then
+    // not), never as an arithmetic combination with structuralScore.
+    const sorted = [...candidates].sort((a, b) => {
+        const evidenceRank = (b.namedByEvidence.length > 0 ? 1 : 0) - (a.namedByEvidence.length > 0 ? 1 : 0);
+        if (evidenceRank !== 0)
+            return evidenceRank;
+        if (b.structuralScore !== a.structuralScore)
+            return b.structuralScore - a.structuralScore;
+        return a.node.id.localeCompare(b.node.id);
+    });
+    const notes = [];
+    if (outcome.truncated) {
+        // Mirrors queries.ts's own `result()` helper — impactOf's equivalent
+        // note, inlined here since this module calls weightedBfs directly (see
+        // module header).
+        notes.push("The node budget was reached, so this answer is partial. Nodes beyond the budget " +
+            "were not examined and are not reported as clean.");
+    }
+    if (outcome.resolutionFloor <= 1) {
+        notes.push(`Trace stopped here: edges are resolved no better than R${outcome.resolutionFloor}, and a ` +
+            "cross-file call at that level may not appear in the graph at all. Candidates beyond an " +
+            "unresolved hop are invisible to this ranking, and their absence must not be read as " +
+            '"no root cause beyond this point" (architecture §18.3\'s resolution caveat).');
+    }
+    const ranked = sorted.slice(0, topN);
+    return {
+        ranked,
+        candidateCount: sorted.length,
+        truncated: outcome.truncated || sorted.length > ranked.length,
+        notes,
+    };
+}
+//# sourceMappingURL=root-cause-score.js.map

package/dist/query/root-cause-score.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-cause-score.js","sourceRoot":"","sources":["../../src/query/root-cause-score.ts"],"names":[],"mappings":"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"}

package/dist/query/row-closure-picture.d.ts

@@ -0,0 +1,108 @@
+/**
+ * DEC-244, extended: the same row can be closed by two different kinds of
+ * evidence at once, and they must never collapse into each other.
+ *
+ * `applyDeclaredValues` (`declared-value-closure.ts`) answers from `.env*`
+ * config alone. `applyConfirmedFacts` (`confirmed-facts.ts`) answers from
+ * human testimony alone, and — since `ConfirmedFact.environment` landed —
+ * testimony can now be scoped to a *named* environment, not just an unscoped
+ * blanket answer. This module is the picture that shows both kinds of
+ * evidence side by side, per environment, without ever letting one stand in
+ * for the other.
+ *
+ * ## The real case that forced this shape
+ *
+ * `sherpa-frontend`'s `import.meta.env.VITE_BACKEND_API_URL` today has, on
+ * disk, in this worktree:
+ *
+ * - `"development"` → `http://localhost:8000`, **declared** — read from
+ *   `.env.development.local`, class A (DEC-244 Row 1).
+ * - `"staging"` → `https://sherpa-backend-staging.up.railway.app`,
+ *   **asserted** — a human-confirmed `ConfirmedFact` with
+ *   `environment: "staging"`, class B. `"staging"` never appears in any
+ *   `.env*` filename here; the *only* reason this module knows it exists at
+ *   all is that a person named it on the fact.
+ * - `"production"` — still entirely unaddressed, by either source, and
+ *   **still unnameable from anything this module reads.**
+ *
+ * ## Why `environment` is never inferred, only ever read
+ *
+ * `ConfirmedFact.environment`'s own doc is explicit: "human-supplied only,
+ * never inferred." This module upholds that by construction — the only
+ * places an environment name enters this picture are `resolve.ts`'s
+ * `knownEnvironments` (from `.env*` **filenames**, DEC-223's own "never
+ * guessed, always refused" rule) and `fact.environment` (typed as the human
+ * literally set it). Nothing here parses `"staging"` out of a hostname; the
+ * hostname's word "staging" and the fact's `environment: "staging"` are
+ * correlated in this specific real case only because a *person* read the
+ * same signal and typed the same word — this module never makes that
+ * connection itself, and would behave identically if the two disagreed.
+ *
+ * ## Why `"closed"` is reserved for fully-declared rows
+ *
+ * A row where every named environment resolves — some from config, some from
+ * testimony — could be called "closed." It is deliberately not: `state`
+ * reaches `"closed"` only when **every** named environment's evidence is
+ * `declared` (class A). One environment resting on testimony keeps the whole
+ * row at `"partially-closed"`, even if nothing is technically unaddressed —
+ * because a caller reading the single word `"closed"` must never have to
+ * re-check `environments[].reliability` to find out whether that word is
+ * hiding an unaudited assertion. This is the concrete answer to "what each
+ * provenance earns, side by side" (DEC-244 Row 1): declared is A, asserted is
+ * B, and the top-level state can never quietly promote a B into looking like
+ * an A.
+ */
+import type { ConfirmedFact, ReliabilityClass, UnresolvedRef } from "@descryy/ir";
+import type { DeclaredEnvValue } from "../ledger/resolve.ts";
+import { type ClosureState } from "./declared-value-closure.ts";
+/** A human-confirmed value with no `environment` on the fact — deliberately not attributed to any named one. */
+export interface AssertedValue {
+    readonly value: string;
+    readonly confirmedBy: string;
+    readonly confirmedAt: string;
+}
+/**
+ * One named environment — named by a `.env*` filename, a scoped
+ * `ConfirmedFact`, or both — and everything either source says about it.
+ */
+export interface EnvironmentValue {
+    readonly environment: string;
+    readonly declaredValue: string | null;
+    readonly declaredFile: string | null;
+    readonly declaredLine: number | null;
+    readonly assertedValue: string | null;
+    readonly assertedBy: string | null;
+    readonly assertedAt: string | null;
+    /** `"A"` when `declaredValue` is set, `"B"` when only a scoped assertion addresses it, `null` when neither. */
+    readonly reliability: ReliabilityClass | null;
+}
+export interface RowClosurePicture {
+    readonly ref: UnresolvedRef;
+    readonly blockedBy: string;
+    /** Every environment either source names, sorted. Never invented beyond what a filename or a fact states. */
+    readonly environments: readonly EnvironmentValue[];
+    /** Facts matching this row's `(repo, blockedBy)` with no `environment` — testimony, scope unspecified. */
+    readonly unscopedAssertions: readonly AssertedValue[];
+    /** `environments` entries with `reliability === null` — named by something, addressed by nothing. */
+    readonly stillUnaddressed: readonly string[];
+    readonly state: ClosureState | "open";
+}
+export interface RowClosureApplication {
+    /** One per askable row, `state` included even when `"open"` — the fuller shape is the point. */
+    readonly pictures: readonly RowClosurePicture[];
+    /** Rows `askableHandle` refused outright: wrong class, unset, no handle. Untouched by either source. */
+    readonly notAskable: readonly UnresolvedRef[];
+}
+/**
+ * Describe every askable row against both sources of evidence at once.
+ *
+ * `declared` and `facts` are both pre-loaded by the caller — same
+ * read-once-apply-many discipline `resolveAgainstDeclared`/
+ * `applyConfirmedFacts` already follow. The fact-matching itself is not
+ * re-derived here: `applyConfirmedFacts` is called once and its output
+ * reused, so the `(repo, blockedBy)` scoping and the askable filter it
+ * already enforces are not re-implemented a second, potentially-diverging
+ * way.
+ */
+export declare function describeRowClosures(refs: readonly UnresolvedRef[], declared: readonly DeclaredEnvValue[], facts: readonly ConfirmedFact[], repo: string): RowClosureApplication;
+//# sourceMappingURL=row-closure-picture.d.ts.map

package/dist/query/row-closure-picture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-closure-picture.d.ts","sourceRoot":"","sources":["../../src/query/row-closure-picture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIlF,OAAO,KAAK,EAAE,gBAAgB,EAA4B,MAAM,sBAAsB,CAAC;AAEvF,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAK5F,gHAAgH;AAChH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,+GAA+G;IAC/G,QAAQ,CAAC,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6GAA6G;IAC7G,QAAQ,CAAC,YAAY,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnD,0GAA0G;IAC1G,QAAQ,CAAC,kBAAkB,EAAE,SAAS,aAAa,EAAE,CAAC;IACtD,qGAAqG;IACrG,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAAC;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,gGAAgG;IAChG,QAAQ,CAAC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAChD,wGAAwG;IACxG,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/C;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,aAAa,EAAE,EAC9B,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,IAAI,EAAE,MAAM,GACX,qBAAqB,CAoEvB"}