gitnexus 1.6.11-rc.46 → 1.6.11-rc.47

package/dist/_shared/graph/types.d.ts

@@ -225,5 +225,33 @@ export interface GraphRelationship {
         readonly weight: number;
         readonly note?: string;
     }[];
+    /**
+     * When `true`, the call site this edge was resolved from sits in a
+     * branch that is provably unreachable from the indexed source at
+     * compile time — e.g. a Zig `if (CONST_FALSE)` body, or the `else` of
+     * `if (CONST_TRUE)`, where the condition folds to a comptime-known
+     * boolean.
+     *
+     * This does NOT change what a `CALLS` edge means. `CALLS` still means
+     * "there is a resolved call site from A to B"; it has never meant "B is
+     * reachable from A", and this flag does not make it mean that.
+     * `staticGated` is additional, statically provable path-feasibility
+     * metadata on the edge: an opt-in
+     * analysis layer that a consumer may read (for example to rank or
+     * filter callers in an impact view) and that no core pass acts on.
+     * The edge is emitted, persisted, traversed and counted exactly as it
+     * was before the flag existed.
+     *
+     * Scope: only conditions that fold from constants in the source.
+     * Anything the index cannot know (build mode, target, environment) is
+     * never marked; the index has no production build configuration and
+     * does not claim to.
+     *
+     * Optional and additive: edges from languages that don't compute
+     * static gating leave this `undefined`, which readers treat
+     * identically to `false` (live). Currently set only by the Zig
+     * scope-capture emitter.
+     */
+    staticGated?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/_shared/graph/types.d.ts.map

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

package/dist/_shared/scope-resolution/reference-site.d.ts

@@ -184,6 +184,16 @@ export interface ReferenceSite {
      * else, so every other language's sites stay byte-identical.
      */
     readonly embeddedAsPointer?: boolean;
+    /**
+     * The call sits inside a branch that is provably unreachable from the
+     * indexed source at compile time — a Zig `if (CONST_FALSE)` body, or the
+     * `else` of `if (CONST_TRUE)`,
+     * where the condition folds to a comptime-known boolean. Set only when
+     * `kind === 'call'` and only by languages that compute static gating (Zig
+     * today); absent everywhere else, so every other site stays byte-identical.
+     * Threaded to `Reference.staticGated` and then `GraphRelationship.staticGated`.
+     */
+    readonly staticGated?: boolean;
 }
 /**
  * One step in a mixed receiver chain — the decoded form of a receiver that is

package/dist/_shared/scope-resolution/reference-site.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,GAWZ,WAAW,GAKX,OAAO,CAAC;AAEZ;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC7D;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED;;;;;;;;;;;;GAYG;AACH;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC"}
+{"version":3,"file":"reference-site.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/reference-site.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,GAWZ,WAAW,GAKX,OAAO,CAAC;AAEZ;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,OAAO,CAAC;AAEnE,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC7D;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IACpC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;;GAYG;AACH;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC"}

package/dist/_shared/scope-resolution/types.d.ts

@@ -675,6 +675,11 @@ export interface Reference {
      * without it is emitted exactly as before.
      */
     readonly callForm?: CallForm;
+    /** Copied from `ReferenceSite.staticGated` for `kind === 'call'`: the site is
+     *  in a branch provably unreachable from the indexed source at compile time.
+     *  The emit phase writes it to `GraphRelationship.staticGated` as metadata;
+     *  see the contract note there. Optional and additive. */
+    readonly staticGated?: boolean;
     readonly confidence: number;
     readonly evidence: readonly ResolutionEvidence[];
 }

package/dist/_shared/scope-resolution/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}

package/dist/core/ingestion/call-extractors/zig-static-gating.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Zig static-gating resolver.
+ *
+ * Detects calls inside `if (CONST_FALSE)` blocks (and trivial boolean
+ * extensions: `and`, `or`, `==`/`!=`, parentheses, and prefix `!` negation,
+ * which tree-sitter-zig parses as `error_union_type`) so the call edge can be
+ * tagged with `staticGated: true`.  The flag lets impact-analysis
+ * consumers filter out paper-tiger callers that live in dead branches
+ * gated behind a comptime-known `false` constant.
+ *
+ * Conservative by design: we only tag an edge when we can prove the
+ * gating expression evaluates to `false`.  Anything ambiguous → live.
+ *
+ * Scope of v1:
+ *
+ *   (a) **File-local** consts (`pub const FOO = false;`, plus const-to-const
+ *       aliases up to 5 hops), built once per file by `buildZigBoolConstMap`.
+ *   (b) **Cross-file** (`const cfg = @import("./cfg.zig"); if (cfg.FOO)`) is
+ *       NOT resolved yet. The evaluator keeps the seam for it (`importAliases`
+ *       + `lookupBoolsForPath`, consumed by the `field_expression` case), but
+ *       the only caller passes an empty alias map and a lookup that always
+ *       returns `undefined`, because the capture emitter runs in the parse
+ *       worker and sees only the current file. Tracked in #3162. Until then
+ *       every `cfg.FOO` condition folds to unknown, i.e. live.
+ *
+ * Also out of scope: multi-hop member access (`cfg.sub.FOO`), re-exported
+ * consts, runtime-evaluated bools (`const FOO = computeIt();`), and
+ * `builtin.mode` gates.
+ *
+ * Wire-up: `stampZigStaticGating` in ../languages/zig/captures.ts calls
+ * `collectZigStaticGatedRanges` once per file and marks every call capture
+ * whose position falls inside a dead range with `@reference.static-gated`;
+ * the scope-resolution pipeline carries that marker to the CALLS edge.
+ */
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+/**
+ * Per-file table of comptime-known booleans:
+ *   `pub const FOO: bool = false;`  →  Map { 'FOO' → false }
+ *   `pub const BAR = true;`         →  Map { 'BAR' → true }
+ *
+ * Constants whose RHS is anything other than a bare `boolean` literal
+ * (e.g. function calls, struct accesses) are intentionally absent —
+ * they resolve to `undefined`.
+ */
+export type ZigBoolConstMap = ReadonlyMap<string, boolean>;
+/**
+ * Per-file `@import` alias map, mapping a local identifier to the
+ * resolved absolute file path of the imported module.  Used for the
+ * `cfg.FOO` cross-file lookup pattern.
+ *
+ *   `const cfg = @import("./cfg.zig");`  →  Map { 'cfg' → 'src/cfg.zig' }
+ */
+export type ZigImportAliasMap = ReadonlyMap<string, string>;
+/**
+ * Cross-file lookup: given an alias-resolved file path, return that
+ * file's known-bool map.  Implemented by the caller — the resolver
+ * itself stays stateless.
+ */
+export type ZigBoolConstLookup = (filePath: string) => ZigBoolConstMap | undefined;
+/**
+ * Walk the top-level of a Zig source file and collect known-bool
+ * constants.  Two passes:
+ *
+ *   Pass 1: collect every top-level `const X = <expr>` where the RHS
+ *           is either a `boolean` literal (recorded in `literals`) or
+ *           a single `identifier` (recorded in `aliases`).
+ *   Pass 2: walk each alias entry up to `MAX_ALIAS_HOPS` hops; if the
+ *           chain terminates at a known-bool literal, record `X` with
+ *           the literal's value. Cycles, chains exceeding the cap, and
+ *           chains exiting file scope (unknown identifier at the root)
+ *           bail to "unknown".
+ *
+ * Only `const` decls qualify (not `var`). The function is permissive
+ * about modifier tokens (`pub`, type annotation) — it reads only the
+ * identifier name and the RHS expression shape.
+ */
+export declare function buildZigBoolConstMap(rootNode: SyntaxNode): ZigBoolConstMap;
+/**
+ * Every source range that is statically dead in this file: the body of an
+ * `if` whose condition folds to `false`, and the `else` clause of an `if`
+ * whose condition folds to `true`. Both the statement form (`if (c) { .. }`)
+ * and the expression form (`const x = if (c) a else b;`) are walked; the
+ * arms differ only in how the grammar exposes them, see `ifExpressionArms`.
+ * Line/col ranges, so a capture layer that
+ * only keeps `Capture.range` (no node) can still stamp its call sites —
+ * that is how the scope-resolution provider consumes this module.
+ *
+ * One walk per file over every `if`, so a call site is classified by
+ * position lookup; nesting needs no special case because an inner branch
+ * inside a dead body is inside the dead body's range already.
+ */
+export interface ZigGatedRange {
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly endLine: number;
+    readonly endCol: number;
+}
+export declare function collectZigStaticGatedRanges(rootNode: SyntaxNode, localBools: ZigBoolConstMap, importAliases: ZigImportAliasMap, lookupBoolsForPath: ZigBoolConstLookup): readonly ZigGatedRange[];
+/** Is a (1-based line, 0-based col) position inside one of `ranges`? */
+export declare function isPositionStaticGated(line: number, col: number, ranges: readonly ZigGatedRange[]): boolean;

package/dist/core/ingestion/call-extractors/zig-static-gating.js

@@ -0,0 +1,319 @@
+// gitnexus/src/core/ingestion/call-extractors/zig-static-gating.ts
+/** Maximum recursion depth when evaluating a boolean condition expression. */
+const MAX_COND_DEPTH = 4;
+// ---------------------------------------------------------------------------
+// Phase 2: per-file extraction
+// ---------------------------------------------------------------------------
+/** Cap on alias-chain hops walked when resolving `const A = B; const B = C; ...`. */
+const MAX_ALIAS_HOPS = 5;
+/**
+ * Walk the top-level of a Zig source file and collect known-bool
+ * constants.  Two passes:
+ *
+ *   Pass 1: collect every top-level `const X = <expr>` where the RHS
+ *           is either a `boolean` literal (recorded in `literals`) or
+ *           a single `identifier` (recorded in `aliases`).
+ *   Pass 2: walk each alias entry up to `MAX_ALIAS_HOPS` hops; if the
+ *           chain terminates at a known-bool literal, record `X` with
+ *           the literal's value. Cycles, chains exceeding the cap, and
+ *           chains exiting file scope (unknown identifier at the root)
+ *           bail to "unknown".
+ *
+ * Only `const` decls qualify (not `var`). The function is permissive
+ * about modifier tokens (`pub`, type annotation) — it reads only the
+ * identifier name and the RHS expression shape.
+ */
+export function buildZigBoolConstMap(rootNode) {
+    const literals = new Map();
+    const aliases = new Map();
+    for (const child of rootNode.namedChildren) {
+        if (child.type !== 'variable_declaration')
+            continue;
+        const entry = extractBoolConstOrAlias(child);
+        if (!entry)
+            continue;
+        if (entry.kind === 'literal') {
+            literals.set(entry.name, entry.value);
+        }
+        else {
+            aliases.set(entry.name, entry.aliasOf);
+        }
+    }
+    // Pass 2: resolve alias chains.
+    for (const [name, target] of aliases) {
+        const resolved = resolveAliasChain(name, target, literals, aliases);
+        if (resolved !== undefined) {
+            literals.set(name, resolved);
+        }
+    }
+    return literals;
+}
+function resolveAliasChain(start, firstTarget, literals, aliases) {
+    // Walk: start → firstTarget → aliases.get(firstTarget) → ... up to MAX_ALIAS_HOPS.
+    // Cycle protection via a visited set seeded with `start` itself.
+    const visited = new Set();
+    visited.add(start);
+    let current = firstTarget;
+    for (let hop = 0; hop < MAX_ALIAS_HOPS; hop++) {
+        if (visited.has(current))
+            return undefined; // cycle
+        visited.add(current);
+        const lit = literals.get(current);
+        if (lit !== undefined)
+            return lit;
+        const next = aliases.get(current);
+        if (next === undefined)
+            return undefined; // chain exits file scope or hits unknown
+        current = next;
+    }
+    return undefined; // hop cap exceeded
+}
+function extractBoolConstOrAlias(decl) {
+    // Require `const` and exclude `var`. tree-sitter-zig parses both with
+    // the same `variable_declaration` shape; the qualifier is an anonymous
+    // child token. A `pub var FOO = false;` is mutable global state — its
+    // initial value is NOT a comptime constant and must not feed gating.
+    let isConst = false;
+    let isVar = false;
+    for (let i = 0; i < decl.childCount; i++) {
+        const c = decl.child(i);
+        if (!c || c.isNamed)
+            continue;
+        if (c.type === 'const')
+            isConst = true;
+        else if (c.type === 'var')
+            isVar = true;
+    }
+    if (!isConst || isVar)
+        return null;
+    let name;
+    let value;
+    let aliasOf;
+    for (const c of decl.namedChildren) {
+        if (c.type === 'identifier' && name === undefined) {
+            name = c.text;
+            continue;
+        }
+        if (c.type === 'boolean') {
+            const t = c.text;
+            if (t === 'true')
+                value = true;
+            else if (t === 'false')
+                value = false;
+        }
+        else if (c.type === 'identifier' && name !== undefined && aliasOf === undefined) {
+            // Second `identifier` child is the RHS alias target:
+            //   `const B = A;`  → name='B', aliasOf='A'.
+            aliasOf = c.text;
+        }
+    }
+    if (name === undefined)
+        return null;
+    if (value !== undefined)
+        return { kind: 'literal', name, value };
+    if (aliasOf !== undefined)
+        return { kind: 'alias', name, aliasOf };
+    return null;
+}
+export function collectZigStaticGatedRanges(rootNode, localBools, importAliases, lookupBoolsForPath) {
+    const out = [];
+    for (const node of rootNode.descendantsOfType(['if_statement', 'if_expression'])) {
+        const cond = findIfCondition(node);
+        const result = cond
+            ? evalCond(cond, localBools, importAliases, lookupBoolsForPath, 0)
+            : undefined;
+        let dead = null;
+        if (node.type === 'if_statement') {
+            if (result === false)
+                dead = node.childForFieldName('body');
+            if (result === true)
+                dead = node.namedChildren.find((c) => c.type === 'else_clause') ?? null;
+        }
+        else {
+            const arms = ifExpressionArms(node);
+            if (result === false)
+                dead = arms.consequence;
+            if (result === true)
+                dead = arms.alternative;
+        }
+        if (dead) {
+            out.push({
+                startLine: dead.startPosition.row + 1,
+                startCol: dead.startPosition.column,
+                endLine: dead.endPosition.row + 1,
+                endCol: dead.endPosition.column,
+            });
+        }
+    }
+    return out;
+}
+/**
+ * The two arms of an `if_expression` (`const x = if (c) a else b;`). Unlike
+ * `if_statement` the grammar gives them no field names and no `else_clause`
+ * wrapper: the consequence is the first named child after the closing `)`
+ * of the condition, the alternative is the first named child after the
+ * anonymous `else` token. Either may be absent.
+ */
+function ifExpressionArms(node) {
+    let consequence = null;
+    let alternative = null;
+    let slot = 'none';
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (!c)
+            continue;
+        if (!c.isNamed) {
+            if (c.type === ')' && slot === 'none')
+                slot = 'consequence';
+            else if (c.type === 'else')
+                slot = 'alternative';
+            continue;
+        }
+        if (slot === 'consequence' && !consequence)
+            consequence = c;
+        else if (slot === 'alternative' && !alternative)
+            alternative = c;
+    }
+    return { consequence, alternative };
+}
+/** Is a (1-based line, 0-based col) position inside one of `ranges`? */
+export function isPositionStaticGated(line, col, ranges) {
+    for (const r of ranges) {
+        if (line < r.startLine || line > r.endLine)
+            continue;
+        if (line === r.startLine && col < r.startCol)
+            continue;
+        if (line === r.endLine && col >= r.endCol)
+            continue;
+        return true;
+    }
+    return false;
+}
+/** Pick the condition node out of an `if_statement`. The condition is
+ * the first named child (the body / else branches come after). */
+function findIfCondition(ifNode) {
+    return ifNode.namedChildren[0] ?? null;
+}
+/**
+ * Evaluate a boolean condition expression to a tribool.
+ *
+ * Handles only the shapes we can resolve symbolically; everything else
+ * returns `undefined` ("unknown — treat as live").
+ */
+function evalCond(node, localBools, importAliases, lookupBoolsForPath, depth) {
+    if (depth > MAX_COND_DEPTH)
+        return undefined;
+    switch (node.type) {
+        case 'boolean': {
+            // Bare literal: `if (false)`.
+            if (node.text === 'true')
+                return true;
+            if (node.text === 'false')
+                return false;
+            return undefined;
+        }
+        case 'identifier': {
+            // Bare flag check: `if (FOO)`.
+            const v = localBools.get(node.text);
+            return v === undefined ? undefined : v;
+        }
+        case 'field_expression': {
+            // `cfg.FOO` — alias hop.
+            const obj = node.namedChildren[0];
+            const member = node.namedChildren[1];
+            if (obj?.type !== 'identifier' || member?.type !== 'identifier') {
+                return undefined;
+            }
+            const targetFile = importAliases.get(obj.text);
+            if (!targetFile)
+                return undefined;
+            const targetBools = lookupBoolsForPath(targetFile);
+            if (!targetBools)
+                return undefined;
+            const v = targetBools.get(member.text);
+            return v === undefined ? undefined : v;
+        }
+        case 'binary_expression': {
+            // `lhs and rhs` / `lhs or rhs` / `lhs == rhs` / `lhs != rhs`.
+            const op = findOperatorToken(node);
+            const lhs = node.namedChildren[0];
+            const rhs = node.namedChildren[1];
+            if (!lhs || !rhs)
+                return undefined;
+            const l = evalCond(lhs, localBools, importAliases, lookupBoolsForPath, depth + 1);
+            const r = evalCond(rhs, localBools, importAliases, lookupBoolsForPath, depth + 1);
+            if (op === 'and') {
+                // `false and *` = false; `* and false` = false.
+                if (l === false || r === false)
+                    return false;
+                if (l === true && r === true)
+                    return true;
+                return undefined;
+            }
+            if (op === 'or') {
+                // Only `false or false` is provably false.
+                if (l === false && r === false)
+                    return false;
+                if (l === true || r === true)
+                    return true;
+                return undefined;
+            }
+            if (op === '==') {
+                // Equality folds when both sides are known booleans.
+                // `FOO == false` ↔ `!FOO`; `FOO == true` ↔ `FOO`.
+                if (l === undefined || r === undefined)
+                    return undefined;
+                return l === r;
+            }
+            if (op === '!=') {
+                if (l === undefined || r === undefined)
+                    return undefined;
+                return l !== r;
+            }
+            // Other comparison ops (<, >, …) — not booleans we can prove.
+            return undefined;
+        }
+        case 'parenthesized_expression': {
+            // `(cond)`: transparent.
+            const inner = node.namedChildren[0];
+            if (!inner)
+                return undefined;
+            return evalCond(inner, localBools, importAliases, lookupBoolsForPath, depth + 1);
+        }
+        case 'error_union_type': {
+            // tree-sitter-zig has no unary `!` node: prefix `!cond` (boolean
+            // negation) parses as `error_union_type` because the same `!` token
+            // introduces error-union types. In condition position that reading is
+            // never a type, so negate whatever the operand folds to: an
+            // identifier, a literal, or a parenthesized compound like `!(A and B)`.
+            const inner = node.namedChildren[0];
+            if (!inner)
+                return undefined;
+            const v = evalCond(inner, localBools, importAliases, lookupBoolsForPath, depth + 1);
+            if (v === undefined)
+                return undefined;
+            return !v;
+        }
+        default:
+            return undefined;
+    }
+}
+/**
+ * Pull the textual operator (e.g. "and", "or") out of a
+ * `binary_expression`.  In tree-sitter-zig, the operator is an
+ * anonymous child token whose `type` equals the operator string.
+ */
+function findOperatorToken(binExpr) {
+    for (let i = 0; i < binExpr.childCount; i++) {
+        const c = binExpr.child(i);
+        if (!c)
+            continue;
+        if (!c.isNamed) {
+            // Anonymous tokens for these ops carry their text as the type.
+            if (c.type === 'and' || c.type === 'or' || c.type === '==' || c.type === '!=') {
+                return c.type;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/core/ingestion/languages/zig/captures.js

@@ -5,6 +5,45 @@ import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 import { hasZigPubKeyword } from '../../export-detection.js';
 import { normalizeZigTypeName } from './interpret.js';
+import { buildZigBoolConstMap, collectZigStaticGatedRanges, isPositionStaticGated, } from '../../call-extractors/zig-static-gating.js';
+/**
+ * A call capture inside an `if (CONST_FALSE)` body (or the `else` of an
+ * `if (CONST_TRUE)`) gets this extra key; `scope-extractor` turns it into
+ * `ReferenceSite.staticGated`
+ * and the emitters copy it onto the CALLS edge. Same idiom as Go's
+ * `@reference.callee-position`: a zero-range marker, present or absent, so
+ * every ungated site's capture set stays byte-identical.
+ */
+const ZERO_RANGE = Object.freeze({ startLine: 0, startCol: 0, endLine: 0, endCol: 0 });
+const STATIC_GATED_MARKER = Object.freeze({
+    name: '@reference.static-gated',
+    range: ZERO_RANGE,
+    text: '',
+});
+const NO_IMPORT_ALIASES = new Map();
+/** Stamp `@reference.static-gated` onto every call capture whose anchor sits
+ *  in a statically dead range. File-local constants only for now (v1): the
+ *  cross-file alias walk in `zig-static-gating.ts` needs the repo file list,
+ *  which the capture layer does not see. */
+function stampZigStaticGating(out, root) {
+    // No early return on an empty constant table: `collectZigStaticGatedRanges`
+    // also folds bare literals (`if (false) { ... }`), which need no constants.
+    const bools = buildZigBoolConstMap(root);
+    const ranges = collectZigStaticGatedRanges(root, bools, NO_IMPORT_ALIASES, () => undefined);
+    if (ranges.length === 0)
+        return out;
+    return out.map((m) => {
+        const key = Object.keys(m).find((k) => k.startsWith('@reference.call.'));
+        if (key === undefined)
+            return m;
+        const anchor = m[key];
+        if (anchor === undefined)
+            return m;
+        return isPositionStaticGated(anchor.range.startLine, anchor.range.startCol, ranges)
+            ? { ...m, '@reference.static-gated': STATIC_GATED_MARKER }
+            : m;
+    });
+}
 /** Zig container node types: `struct`, `enum`, `union` and the fieldless
  *  `opaque` all bind through `const T = <container> {…}` and may own methods.
  *  Single source for the class/field/method extractor configs. */
@@ -1661,7 +1700,7 @@ export function emitZigScopeCaptures(sourceText, _filePath, cachedTree) {
     // second pass rewrites that name inside the receiver text it just minted.
     rewriteZigDeepAliasReferences(out, deepAliases.aliases);
     rewriteZigFunctionLocalImportNames(out, fnLocalImports);
-    return out;
+    return stampZigStaticGating(out, tree.rootNode);
 }
 // ─── Use-site rewrites (8.4 / 8.9) and result-location sites (8.6) ────────────
 /** The unique spelling a function-local import binding gets: `m$<callable>`

package/dist/core/ingestion/resolve-references.js

@@ -256,6 +256,7 @@ function buildReference(site, top) {
         // construction sites (`callForm: 'constructor'`) on the CALLS edge it
         // emits — a `Reference` otherwise keeps only the resolved def.
         ...(site.kind === 'call' && site.callForm !== undefined ? { callForm: site.callForm } : {}),
+        ...(site.kind === 'call' && site.staticGated === true ? { staticGated: true } : {}),
         confidence: top.confidence,
         evidence: top.evidence,
     };

package/dist/core/ingestion/scope-extractor.js

@@ -1031,6 +1031,11 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
         // detection knows what to do with that. Absent for every language without
         // pointer embedding, so their sites stay byte-identical.
         const embeddedAsPointer = match['@reference.embedded-pointer'] !== undefined;
+        // Static-gating marker: the call sits in a branch the language layer proved
+        // dead at index time (Zig `if (CONST_FALSE)`). Recorded on the site and
+        // copied to the CALLS edge; absent everywhere else (see
+        // `ReferenceSite.staticGated`).
+        const staticGated = kind === 'call' && match['@reference.static-gated'] !== undefined;
         const site = {
             name: nameCap.text,
             atRange: anchor.range,
@@ -1051,6 +1056,7 @@ function pass5CollectReferences(matches, positionIndex, filePath, referenceSites
             ...(receiverChain !== undefined ? { receiverChain } : {}),
             ...(inCalleePosition ? { inCalleePosition: true } : {}),
             ...(embeddedAsPointer ? { embeddedAsPointer: true } : {}),
+            ...(staticGated ? { staticGated: true } : {}),
         };
         referenceSites.push(site);
     }
@@ -1469,6 +1475,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@reference.property-key',
     '@reference.callee-position',
     '@reference.embedded-pointer',
+    '@reference.static-gated',
     '@reference.receiver',
     '@reference.operator',
     '@reference.arity',

package/dist/core/ingestion/scope-resolution/graph-bridge/edges.d.ts

@@ -55,6 +55,8 @@ export declare function tryEmitEdge(graph: KnowledgeGraph, scopes: ScopeResoluti
     /** See {@link isPhantomCalleeRead}. Set by the extractor from the
      *  language's `@reference.callee-position` marker; absent otherwise. */
     readonly inCalleePosition?: boolean;
+    /** See `ReferenceSite.staticGated`; copied onto the emitted edge. */
+    readonly staticGated?: boolean;
 }, targetDef: SymbolDefinition, reason: string, seen: Set<string>, confidence?: number, collapseByCallerTarget?: boolean, calleeCapture?: CalleeIdCaptureCtx): boolean;
 /**
  * Variant of `tryEmitEdge` that takes a pre-resolved target graph id
@@ -85,4 +87,6 @@ export declare function tryEmitEdgeWithExplicitTargetId(graph: KnowledgeGraph, s
         startCol: number;
     };
     readonly kind: string;
+    /** See `ReferenceSite.staticGated`; copied onto the emitted edge. */
+    readonly staticGated?: boolean;
 }, targetGraphId: string, reason: string, seen: Set<string>, confidence?: number, collapseByCallerTarget?: boolean, calleeCapture?: CalleeIdCaptureCtx): boolean;

package/dist/core/ingestion/scope-resolution/graph-bridge/edges.js

@@ -133,6 +133,7 @@ export function tryEmitEdge(graph, scopes, nodeLookup, site, targetDef, reason,
         type: edgeType,
         confidence,
         reason,
+        ...(site.staticGated === true ? { staticGated: true } : {}),
     });
     return true;
 }
@@ -184,6 +185,7 @@ export function tryEmitEdgeWithExplicitTargetId(graph, scopes, nodeLookup, site,
         type: edgeType,
         confidence,
         reason,
+        ...(site.staticGated === true ? { staticGated: true } : {}),
     });
     return true;
 }

package/dist/core/ingestion/scope-resolution/graph-bridge/references-to-edges.js

@@ -140,6 +140,7 @@ functionLocalValueDefIds, options) {
                 type: edgeType,
                 confidence: ref.confidence,
                 reason: referenceEdgeReason(ref, options?.markConstructionSites),
+                ...(ref.staticGated === true ? { staticGated: true } : {}),
             });
             emitted++;
         }

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -79,6 +79,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
         return owners.has(instanceOwnerKey(ownerId));
     };
     for (const parsed of parsedFiles) {
+        const pending = new Map();
         const bindingCandidatesByScope = options.freeCallsRequireInstanceOwnership === true
             ? new Map()
             : undefined;
@@ -462,22 +463,38 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // SiteRecord.at: 1-based line / 0-based col).
             options.calleeIdSink?.add(parsed.filePath, site.atRange.startLine, site.atRange.startCol, tgtGraphId);
             const relId = `rel:CALLS:${callerGraphId}->${tgtGraphId}`;
+            // One edge per (caller, callee): `staticGated` is the AND over every site
+            // that collapses into it, so a callee reached from one live site and one
+            // dead site stays live whichever site the walk meets first. Emission is
+            // deferred to the end of this file's sites for that reason.
+            const pendingRel = pending.get(relId);
+            if (pendingRel !== undefined) {
+                if (site.staticGated !== true)
+                    pendingRel.gatedAll = false;
+                continue;
+            }
             if (seen.has(relId))
                 continue;
             seen.add(relId);
-            graph.addRelationship({
-                id: relId,
-                sourceId: callerGraphId,
-                targetId: tgtGraphId,
-                type: 'CALLS',
-                confidence: 0.85,
-                // Match legacy DAG's reason convention so consumers that
-                // assert `reason === 'import-resolved'` keep working. The
-                // construction-site marker is opt-in for the same reason.
-                reason: constructionSiteReason(fnDef.filePath !== parsed.filePath ? 'import-resolved' : 'local-call', site, options.markConstructionSites),
+            pending.set(relId, {
+                gatedAll: site.staticGated === true,
+                rel: {
+                    id: relId,
+                    sourceId: callerGraphId,
+                    targetId: tgtGraphId,
+                    type: 'CALLS',
+                    confidence: 0.85,
+                    // Match legacy DAG's reason convention so consumers that
+                    // assert `reason === 'import-resolved'` keep working. The
+                    // construction-site marker is opt-in for the same reason.
+                    reason: constructionSiteReason(fnDef.filePath !== parsed.filePath ? 'import-resolved' : 'local-call', site, options.markConstructionSites),
+                },
             });
             emitted++;
         }
+        for (const { rel, gatedAll } of pending.values()) {
+            graph.addRelationship(gatedAll ? { ...rel, staticGated: true } : rel);
+        }
     }
     return emitted;
 }

package/dist/core/lbug/csv-generator.d.ts

@@ -115,7 +115,7 @@ export declare const isBinaryContent: (content: string) => boolean;
 export declare const normalizeFtsText: (text: string) => string;
 /** Canonical relationship CSV header — shared by the emit pass and the
  * `splitRelCsvByLabelPair` differential oracle. */
-export declare const REL_CSV_HEADER = "from,to,type,confidence,reason,step";
+export declare const REL_CSV_HEADER = "from,to,type,confidence,reason,step,staticGated";
 /** Build the escaped CSV row (no trailing newline) for one relationship.
  * Single source of the relationship row bytes — used by the emit pass and by
  * the byte-identity differential test that feeds the legacy split oracle. */

package/dist/core/lbug/csv-generator.js

@@ -351,7 +351,7 @@ class BufferedCSVWriter {
 // ============================================================================
 /** Canonical relationship CSV header — shared by the emit pass and the
  * `splitRelCsvByLabelPair` differential oracle. */
-export const REL_CSV_HEADER = 'from,to,type,confidence,reason,step';
+export const REL_CSV_HEADER = 'from,to,type,confidence,reason,step,staticGated';
 /** Build the escaped CSV row (no trailing newline) for one relationship.
  * Single source of the relationship row bytes — used by the emit pass and by
  * the byte-identity differential test that feeds the legacy split oracle. */
@@ -362,6 +362,10 @@ export const buildRelRow = (rel) => [
     escapeCSVNumber(rel.confidence, 1.0),
     escapeCSVField(rel.reason),
     escapeCSVNumber(rel.step, 0),
+    // `staticGated` persists as 0/1 (LadybugDB BOOLEAN COPY accepts both).
+    // Every edge that does not carry the flag writes 0, so readers treat
+    // absence and `false` identically.
+    rel.staticGated === true ? '1' : '0',
 ].join(',');
 /** Canonical BasicBlock node CSV header — taint/PDG substrate (issue #2080).
  * No `name` column; blocks are identified by id + source span. Shared by the

package/dist/core/lbug/lbug-adapter.js

@@ -1259,20 +1259,24 @@ export const fallbackRelationshipInserts = async (validRelLines, validTables, ge
     for (let i = 1; i < validRelLines.length; i++) {
         const line = validRelLines[i];
         try {
-            const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)",([0-9-]+)/);
+            // CSV layout: from,to,type,confidence,reason,step[,staticGated]
+            // The trailing `staticGated` column (0/1) is optional so we remain
+            // tolerant of legacy CSVs written before the column existed.
+            const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)",([0-9-]+)(?:,([01]))?/);
             if (!match)
                 continue;
-            const [, fromId, toId, relType, confidenceStr, reason, stepStr] = match;
+            const [, fromId, toId, relType, confidenceStr, reason, stepStr, gatedStr] = match;
             const fromLabel = getNodeLabel(fromId);
             const toLabel = getNodeLabel(toId);
             if (!validTables.has(fromLabel) || !validTables.has(toLabel))
                 continue;
             const confidence = parseFloat(confidenceStr) || 1.0;
             const step = parseInt(stepStr) || 0;
+            const staticGated = gatedStr === '1';
             await queryAndDrain(conn, `
         MATCH (a:${escapeLabel(fromLabel)} {id: ${formatCypherValue(fromId)} }),
               (b:${escapeLabel(toLabel)} {id: ${formatCypherValue(toId)} })
-        CREATE (a)-[:${REL_TABLE_NAME} {type: ${formatCypherValue(relType)}, confidence: ${confidence}, reason: ${formatCypherValue(reason)}, step: ${step}}]->(b)
+        CREATE (a)-[:${REL_TABLE_NAME} {type: ${formatCypherValue(relType)}, confidence: ${confidence}, reason: ${formatCypherValue(reason)}, step: ${step}, staticGated: ${staticGated}}]->(b)
       `);
         }
         catch {

package/dist/core/lbug/schema.js

@@ -627,7 +627,8 @@ ${generatedPairDdl()},
   type STRING,
   confidence DOUBLE,
   reason STRING,
-  step INT32
+  step INT32,
+  staticGated BOOLEAN
 )`;
 // ============================================================================
 // EMBEDDING TABLE SCHEMA

package/dist/mcp/local/local-backend.js

@@ -6023,8 +6023,8 @@ export class LocalBackend {
             // retains the strongest evidence, the safer default for a blast-radius
             // tool. `sourceId` closes the order for edges that tie on both.
             const query = direction === 'upstream'
-                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence`
-                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence`;
+                ? `MATCH (caller)-[r:CodeRelation]->(n) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, caller.id AS id, caller.name AS name, labels(caller)[0] AS type, caller.filePath AS filePath, r.type AS relType, r.confidence AS confidence, r.staticGated AS staticGated`
+                : `MATCH (n)-[r:CodeRelation]->(callee) WHERE n.id IN $frontierIds AND r.type IN $relTypes${confidenceFilter} RETURN n.id AS sourceId, callee.id AS id, callee.name AS name, labels(callee)[0] AS type, callee.filePath AS filePath, r.type AS relType, r.confidence AS confidence, r.staticGated AS staticGated`;
             try {
                 const related = await executeParameterized(repo.lbugPath, query, {
                     frontierIds: frontier,
@@ -6039,6 +6039,9 @@ export class LocalBackend {
                     relType: rel.relType || rel[5],
                     confidence: rel.confidence ?? rel[6],
                     sourceId: String(rel.sourceId ?? rel[0] ?? ''),
+                    // Set only by languages that compute static gating (Zig); null/undefined
+                    // from older indexes or other languages reads as live.
+                    ...((rel.staticGated ?? rel[7]) === true ? { staticGated: true } : {}),
                 }));
                 // The pdg bridge is the ONE consumer here that accumulates sequentially
                 // rather than per-node: at depth ≥ 2 an edge inherits
@@ -6112,6 +6115,9 @@ export class LocalBackend {
                         filePath: edge.filePath,
                         relationType,
                         confidence: effectiveConfidence,
+                        // Surfaced, never acted on: traversal and ranking ignore the flag
+                        // (see GraphRelationship.staticGated). Absent = live or unmodelled.
+                        ...(edge.staticGated === true ? { staticGated: true } : {}),
                     });
                 }
             }

package/dist/mcp/tools.js

@@ -442,7 +442,7 @@ Output includes:
 - summary: direct callers, processes affected, modules affected
 - affected_processes: which execution flows break and at which step
 - affected_modules: which functional areas are hit (direct vs indirect; classification-unavailable when that secondary query fails)
-- byDepth: affected symbols grouped by traversal depth (paginated by limit/offset; omitted when summaryOnly:true — use byDepthCounts for totals per depth, pagination object when truncated). Each item includes a processes:[{id,label,processType,step}] field listing the execution flows that symbol participates in. Empty when the symbol has no process membership. Can ALSO be empty when partial:true is set — either the process-aggregation pass hit its cap before detecting affected processes, or per-symbol enrichment was capped on a very large page. When partial:true, do NOT treat processes:[] as proof of no participation; cross-check the top-level affected_processes list.
+- byDepth: affected symbols grouped by traversal depth (paginated by limit/offset; omitted when summaryOnly:true — use byDepthCounts for totals per depth, pagination object when truncated). Each item includes a processes:[{id,label,processType,step}] field listing the execution flows that symbol participates in. Empty when the symbol has no process membership. Can ALSO be empty when partial:true is set — either the process-aggregation pass hit its cap before detecting affected processes, or per-symbol enrichment was capped on a very large page. When partial:true, do NOT treat processes:[] as proof of no participation; cross-check the top-level affected_processes list. An item carries staticGated:true only when the edge that reached it is provably unreachable at compile time from the indexed source (today: Zig calls inside an 'if (CONST_FALSE)' body or the else of 'if (CONST_TRUE)'); the field is absent when the edge is live or the language does not model it. Traversal and risk do NOT filter or rank on it: it is metadata for the caller to weigh.
 - epistemic: 'exact' | 'lower-bound' — whether impactedCount is the whole story. 'lower-bound' means the walk provably missed callers, so the count is a floor. Absent only on skipped probes (ambiguous-candidate lists, group fan-out).
 - boundaries: string[] — one plain-language sentence per reason the count is short. Prose for humans; branch on causes instead.
 - causes: { scopeExtractionFiles, receiverTyping, dispatchBoundary, externalBoundary, undecidedSatisfaction } — the machine-readable split of WHY, so an agent gating its own edits can tell a fixable analyzer gap from an irreducible one. Every field counts MISSING THINGS, never sentences:

package/dist/storage/parse-cache.js

@@ -727,7 +727,10 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // byte-identical graph until `parse-cache/` and `parsedfile-cache/` were
 // deleted by hand. 92 is the next free value above origin/main (91) at merge
 // time. RE-CHECK AGAINST origin/main AND OPEN PRs IMMEDIATELY BEFORE MERGING.
-const SCHEMA_BUMP = 92;
+// v93: Zig call captures inside a comptime-false branch carry
+// `@reference.static-gated` (feat/zig-static-gated-edges); the site gains
+// `staticGated` and the CALLS edge a BOOLEAN column.
+const SCHEMA_BUMP = 93;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.46",
+  "version": "1.6.11-rc.47",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",