gitnexus 1.6.10-rc.99 → 1.6.10

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

@@ -98,8 +98,96 @@ export type ParsedImport =
     readonly importedName: string;
     readonly targetRaw: string;
     /** Provider-specific imported symbol category when module and symbol
-     * namespaces have distinct resolution rules (for example PHP). */
+     * namespaces have distinct resolution rules (for example PHP).
+     *
+     * **Not** the same fact as {@link ParsedImport.typeOnly} — see the note
+     * on `typeOnly` below, which is documented on this variant. */
     readonly importedSymbolKind?: 'type' | 'function' | 'const';
+    /**
+     * Is this import ERASED before the module ever runs?
+     *
+     * TypeScript `import type { X } from './m'` and `import { type X }` are
+     * deleted by `tsc`: no `require`/`import` for `./m` survives in the
+     * emitted JavaScript, so the pair cannot force a module-INITIALIZATION
+     * order and cannot participate in an init cycle. That is the one thing
+     * `check --cycles` exists to find, so the fact has to survive from the
+     * syntax down to the emitted `IMPORTS` edge — see `ImportEdge.typeOnly`
+     * and `graph-bridge/imports-to-edges.ts`.
+     *
+     * **Distinct from `importedSymbolKind: 'type'`, which is NOT a substitute.**
+     * That field is a resolution-NAMESPACE category (PHP's `use function` /
+     * `use const` split), it exists only on this variant, and it says "the
+     * thing imported is a type". A symbol being a type says nothing about
+     * whether the import STATEMENT is erased, and PHP erases nothing at all.
+     * This field is about the statement's runtime existence, not the symbol's
+     * category.
+     *
+     * Set only by providers whose syntax marks it. Absent everywhere else,
+     * which reads as "not erased" — the fail-safe direction, since it only
+     * makes `check --cycles` over-report.
+     *
+     * That fail-safe matters more than it first looks, because an explicit
+     * `type` is a SUFFICIENT signal of erasure and not a necessary one. With
+     * neither `verbatimModuleSyntax` nor `importsNotUsedAsValues: preserve`
+     * set — this repo sets neither — `tsc` also elides a plain
+     * `import { SomeInterface }` whose bindings are every one of them used in
+     * type position. Those statements are erased at run time and carry no
+     * marker, so they stay tagged as initializing and `check --cycles` can
+     * still report a cycle that cannot exist. Closing that gap needs
+     * whole-program binding USE information, not import syntax, which is why
+     * this field stops at what the syntax states.
+     */
+    readonly typeOnly?: boolean;
+    /**
+     * Was this import written inside a function body — so that it runs only
+     * when something CALLS that function, never while the module itself is
+     * initializing?
+     *
+     * Python's `def f(): from x import Y` and a CommonJS
+     * `function f() { const { Y } = require('./x'); }` are the spellings.
+     * Both are syntactically ordinary imports — no `kind` tells them apart
+     * from a top-level one, and nothing about the target does either. Only
+     * their POSITION defers them.
+     *
+     * Not every language's imports are like that, and the rule is wrong for
+     * the ones that are not: Rust's `use` and C/C++'s `#include` are legal
+     * in a function body and are deferred by NOTHING, because neither is an
+     * executed statement. Those providers opt out — see
+     * `LanguageProvider.importsExecuteWhereWritten`, below.
+     *
+     * **Why this cannot be re-derived downstream — the whole reason the
+     * field exists.** The natural place to decide it looks like the graph
+     * bridge, by walking the scope the finalized edges hang off; that is
+     * exactly what `graph-bridge/imports-to-edges.ts` once attempted, and it
+     * is dead code by construction. `finalize-algorithm.ts:295` publishes
+     * every file's finalized edges as
+     * `linkedByScope.set(file.moduleScope, …)`, so the map the bridge
+     * receives is keyed by the file's **Module** scope and by nothing else:
+     * the walk starts at a `Module` every time and answers `false` for every
+     * import in the tree. Finalize cannot recover the position either —
+     * `FinalizeFile.parsedImports` is a flat per-file `ParsedImport[]` with
+     * no scope attached. The extractor is the last stage that still knows
+     * where the statement sat (`scope-extractor.ts`, Pass 3), so it marks the
+     * fact here and it rides the edge from there — see
+     * {@link ImportEdge.runsOnlyWhenCalled}.
+     *
+     * Consumed by `check --cycles`, which asks "can these modules be
+     * initialized in any order?". A deferred import carries no
+     * initialization order, and deferring one is the standard way to BREAK
+     * an init cycle, so counting it reports the fix as the bug.
+     *
+     * Set by the central extractor for every language, not by providers —
+     * except that a provider may declare that its imports do not execute
+     * where they are written (`LanguageProvider.importsExecuteWhereWritten:
+     * false`) and be skipped entirely. C, C++, Rust and COBOL do. A `#include`
+     * or a `use` inside a function body is not deferred: the header is
+     * spliced and the path alias is resolved before anything runs, so the
+     * pair really is a dependency and the cycle it can form is real.
+     *
+     * Absent reads as "runs at initialization" — the fail-safe direction,
+     * since it only makes `check --cycles` over-report.
+     */
+    readonly runsOnlyWhenCalled?: boolean;
     /**
      * Set by providers when `targetRaw` already names the imported symbol
      * rather than only its containing module. Consumers that compose
@@ -107,6 +195,40 @@ export type ParsedImport =
      * duplicating `importedName`.
      */
     readonly targetIncludesImportedName?: boolean;
+    /**
+     * Set by providers whose import syntax *also* republishes the name from
+     * the importing module, so a third file can import it from there.
+     *
+     * Python has no dedicated re-export form: a module-level
+     * `from pkg.impl import X` binds `X` locally **and** publishes it as
+     * `pkg.X`, which is the standard way a package `__init__.py` declares
+     * its public surface. Languages with an explicit form (TS `export … from`,
+     * Rust `pub use`) emit `kind: 'reexport'` instead and leave this unset.
+     *
+     * **The flag must track actual republication, not syntax.** Only a
+     * module-level statement publishes: the same `from m import X` inside a
+     * `def` or `class` body binds locally and puts nothing in the module
+     * namespace, so flagging it fabricates a re-export of a name no importer
+     * can reach. `if` / `try` / `for` / `with` do not suppress it — Python
+     * has no block scope. A provider that cannot tell these apart at
+     * interpret time must carry the fact down from its capture emitter,
+     * where the syntax node is still available.
+     *
+     * **Why not `kind: 'reexport'`.** Not because that form drops the local
+     * binding — `materializeBindings` creates a module-scope `BindingRef`
+     * for every linked edge, re-export included. It is that `reexport`
+     * changes what the binding *is*: `origin` flips to `'reexport'`, which
+     * carries different evidence weight and `ORIGIN_PRIORITY`, and it
+     * misreports the parse-time syntax Python actually wrote. A flag adds
+     * the export-surface fact without restating the import as something the
+     * source does not say.
+     *
+     * Consumed by `buildReexportClosures` (`finalize-algorithm.ts`), which
+     * also documents how ambiguous duplicates of one published name are
+     * handled — the precedence rules that hold for an explicit re-export do
+     * not carry over.
+     */
+    readonly reexportsName?: boolean;
 }
 /**
  * Per-name import with rename.
@@ -123,8 +245,18 @@ export type ParsedImport =
     readonly targetRaw: string;
     /** See the same field on the `named` variant. */
     readonly importedSymbolKind?: 'type' | 'function' | 'const';
+    /** See the same field on the `named` variant — including why it is not
+     *  interchangeable with `importedSymbolKind`. Reaches this variant from
+     *  `import type D from './m'` and `import { type X as Y } from './m'`. */
+    readonly typeOnly?: boolean;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  Python's `def f(): from x import Y as Z` and a CommonJS
+     *  `function f() { const { Y: Z } = require('./x'); }`. */
+    readonly runsOnlyWhenCalled?: boolean;
     /** See the same field on the `named` variant. */
     readonly targetIncludesImportedName?: boolean;
+    /** See the same field on the `named` variant. */
+    readonly reexportsName?: boolean;
 }
 /**
  * Qualified module handle, with or without rename. `importedName` is the
@@ -144,6 +276,12 @@ export type ParsedImport =
     /** Module being aliased (e.g. `numpy` in `import numpy as np`). */
     readonly importedName: string;
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  TypeScript `import type * as N from './m'`. */
+    readonly typeOnly?: boolean;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  Python's `def f(): import numpy as np`. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Syntactically-detectable parse-time re-export. Finalize may still produce
@@ -165,6 +303,19 @@ export type ParsedImport =
     readonly targetRaw: string;
     /** Set when the re-export renames the symbol (e.g. `export { X as Y } from './y'`). */
     readonly alias?: string;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  TypeScript `export type { X } from './y'` and `export { type X } from './y'`. */
+    readonly typeOnly?: boolean;
+    /** See the same field on the `named` variant. NO spelling reaches this
+     *  variant today: the two providers that emit `reexport` are TypeScript
+     *  / JavaScript, whose `export … from` is a module-top-level-only
+     *  declaration, and Rust, whose `pub use` is a compile-time path alias
+     *  that its provider exempts from the position rule outright
+     *  (`LanguageProvider.importsExecuteWhereWritten`). Kept because the
+     *  extractor sets the field with no `switch` on `kind`, so a re-export
+     *  form that IS an executed statement would be tagged the moment one
+     *  appears — not because anything sets it now. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Wildcard import — brings every exported name from the target module into
@@ -176,10 +327,26 @@ export type ParsedImport =
  *   - Python `from foo import *`   → `{ kind: 'wildcard', targetRaw: 'foo' }`
  *   - JS `export * from './foo'`   → `{ kind: 'wildcard', targetRaw: './foo' }`
  *   - Rust `pub use foo::*`         → `{ kind: 'wildcard', targetRaw: 'foo' }`
+ *
+ * No `typeOnly` here on purpose. The one syntax that would set it,
+ * TypeScript 5.0's `export type * from './m'`, is not parsed by the
+ * vendored tree-sitter-typescript grammar — it yields an `ERROR` node
+ * holding the bare `type` token, so the fact is not readable at the
+ * statement level (see `typescript/import-decomposer.ts`). Add the field
+ * with the grammar that can express it, not before.
  */
  | {
     readonly kind: 'wildcard';
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Present here although
+     *  `typeOnly` is not: erasure is a syntactic fact this spelling cannot
+     *  express, but POSITION is not — Ruby's `def f; require './m'; end` is
+     *  a wildcard (everything in the required file becomes visible) and IS
+     *  deferred. Python cannot reach it: `from x import *` inside a `def` is
+     *  a SyntaxError. Rust's fn-local `use foo::*` is legal but not
+     *  deferred — `use` does not execute
+     *  (`LanguageProvider.importsExecuteWhereWritten`). */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Runtime-computed target — the import path is not a static literal at
@@ -196,6 +363,9 @@ export type ParsedImport =
     readonly localName: string;
     /** Source text of the unresolved expression when available; `null` otherwise. */
     readonly targetRaw: string | null;
+    /** See the same field on the `named` variant. Set by position like every
+     *  other variant; this kind links no target, so nothing reads it here. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Lazy / dynamic import whose target IS a static string literal at parse
@@ -217,6 +387,10 @@ export type ParsedImport =
  | {
     readonly kind: 'dynamic-resolved';
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Redundant on this kind —
+     *  `import()` is already deferred wherever it is written — but set
+     *  uniformly, because position is decided without consulting `kind`. */
+    readonly runsOnlyWhenCalled?: boolean;
 }
 /**
  * Bare-source / side-effect import that introduces no local name binding
@@ -232,6 +406,10 @@ export type ParsedImport =
  | {
     readonly kind: 'side-effect';
     readonly targetRaw: string;
+    /** See the same field on the `named` variant. Reaches this variant from
+     *  a bare CommonJS `function f() { require('./polyfill'); }` — the ESM
+     *  spelling `import './polyfill'` cannot, being top-level only. */
+    readonly runsOnlyWhenCalled?: boolean;
 };
 /**
  * Provider-interpreted type binding. The provider's `interpretTypeBinding`
@@ -242,8 +420,24 @@ export type ParsedImport =
 export interface ParsedTypeBinding {
     /** The name being bound (parameter name, `self`, assignment LHS, …). */
     readonly boundName: string;
-    /** The raw type name as written in source (`'User'`, `'models.User'`, …). */
+    /** The type name AFTER this provider's normalization (`'User'`,
+     *  `'models.User'`, …) — see `TypeRef.rawName`. */
     readonly rawTypeName: string;
+    /**
+     * Optional override for `TypeRef.declaredSpelling`, for a grammar that does
+     * not keep the whole written type under `@type-binding.type`.
+     *
+     * The scope extractor derives the spelling from that capture by default,
+     * which is right for every language whose type node spans the annotation.
+     * C++ is the exception: `User* repos` parses with the `*` on the DECLARATOR,
+     * so the type capture is a bare `User` and the container-ness the index step
+     * needs is nowhere in the captures the extractor reads. A provider that can
+     * reconstruct it exactly sets it here.
+     *
+     * Leave undefined otherwise — the extractor's derivation is preferred to a
+     * per-language reimplementation of it.
+     */
+    readonly declaredSpelling?: string;
     readonly source: TypeRef['source'];
 }
 /**
@@ -292,6 +486,37 @@ export interface ImportEdge {
     readonly kind: 'named' | 'alias' | 'namespace' | 'wildcard-expanded' | 'reexport' | 'dynamic-unresolved' | 'dynamic-resolved' | 'side-effect';
     /** Re-export chain, for provenance (e.g., `['./y']` when re-exported via `./y`). */
     readonly transitiveVia?: readonly string[];
+    /**
+     * The import is erased before the module runs — see `ParsedImport`'s
+     * `typeOnly` on the `named` variant for the full note, including why
+     * `importedSymbolKind: 'type'` is a different fact and not a substitute.
+     *
+     * Carried straight from the `ParsedImport` by `makeEdgeDrafts`. The edge is
+     * still emitted: a type-only import is a real source-level dependency that
+     * `impact` and `trace` must see, and editing the target still breaks the
+     * importer's typecheck. What the flag removes is the claim that the pair
+     * forces an INITIALIZATION order.
+     */
+    readonly typeOnly?: boolean;
+    /**
+     * The import was written inside a function body, so it runs only when that
+     * function is called — never during module initialization. See
+     * `ParsedImport`'s `runsOnlyWhenCalled` on the `named` variant for the full
+     * note, including why the consumer cannot re-derive this from the scope tree
+     * and therefore has to be told (`finalize-algorithm.ts:295`).
+     *
+     * Carried straight from the `ParsedImport` by `makeEdgeDrafts`, for the same
+     * reason `typeOnly` is: the edge is where `graph-bridge/imports-to-edges.ts`
+     * can still see it. The edge is still emitted either way — a deferred import
+     * is a real dependency. What the flag removes is the claim that the pair
+     * forces an INITIALIZATION order.
+     *
+     * Distinct from `kind === 'dynamic-resolved'`, which records the OTHER way an
+     * import can be deferred (`import('./m')`). Neither implies the other: a
+     * top-level `import()` is deferred with this flag unset, and a function-local
+     * `from x import Y` is deferred with an ordinary `named` kind.
+     */
+    readonly runsOnlyWhenCalled?: boolean;
     /** Set to `'unresolved'` when the SCC fixpoint could not link this edge. */
     readonly linkStatus?: 'unresolved';
 }
@@ -308,6 +533,11 @@ export interface BindingRef {
     readonly origin: 'local' | 'import' | 'namespace' | 'wildcard' | 'reexport';
     /** Non-null for non-local origins; carries the `ImportEdge` that brought the name into this scope. */
     readonly via?: ImportEdge;
+    /**
+     * Optional semantic visibility evidence supplied by a language hook.
+     * Shared resolution consumes this without inspecting language syntax.
+     */
+    readonly visibility?: 'static-member-import';
 }
 /**
  * A reference to a named type, anchored at its declaration site.
@@ -319,8 +549,36 @@ export interface BindingRef {
  * re-exports, and nested modules. Generics deferred to V2 via `typeArgs`.
  */
 export interface TypeRef {
-    /** The name as written in source (e.g., `'User'`, `'models.User'`, `'List'`). */
+    /**
+     * The type name AFTER the language's capture-time normalization — NOT
+     * necessarily what the source says. Every provider's `interpretTypeBinding`
+     * reduces the annotation before it gets here: TypeScript runs
+     * `stripGeneric` + `stripArraySuffix` to a FIXED POINT (`User[][]` → `User`),
+     * Go's `normalizeGoTypeName` drops `[]` and `map[K]`, C#/Python/Kotlin/Rust
+     * strip their single-arg collection wrappers. What survives is the name a
+     * class lookup can use (`'User'`, `'models.User'`, `'List'`).
+     *
+     * A consumer that needs the CONTAINER, not the element, must read
+     * `declaredSpelling` — see below.
+     */
     readonly rawName: string;
+    /**
+     * The annotation exactly as written, kept ONLY when `rawName` is not it.
+     *
+     * `rawName` alone cannot distinguish `repos: User[]` (a container the capture
+     * layer already reduced, so the position IS the element) from `grid: Grid`
+     * (an ordinary class the source happened to subscript). Both arrive as a bare
+     * class name that resolves. An index step reading only `rawName` therefore had
+     * no choice but to guess, and guessing "already reduced" typed `grid[0]` as
+     * `Grid` — a confidently WRONG owner for the next member.
+     *
+     * Absent when the provider's normalization was a no-op (nothing was lost, so
+     * `rawName` is already the written spelling), and absent for TypeRefs
+     * synthesized outside the capture path (a `this` receiver binding, a
+     * propagated return type). Consumers must treat absence as "no container
+     * evidence" and decline, never as "not a container".
+     */
+    readonly declaredSpelling?: string;
     /** Anchor for resolving `rawName` — the scope where the annotation/inference was written. */
     readonly declaredAtScope: ScopeId;
     readonly source: 'annotation' | 'parameter-annotation' | 'return-annotation' | 'self' | 'assignment-inferred' | 'constructor-inferred' | 'receiver-propagated';
@@ -349,6 +607,23 @@ export interface Scope {
     readonly imports: readonly ImportEdge[];
     /** Local type facts visible from this scope (parameter annotations, `self` binding, etc.). */
     readonly typeBindings: ReadonlyMap<string, TypeRef>;
+    /** Lexically bound names that may have no definition or type fact of their
+     * own (for example, an untyped function parameter). Consumers use this only
+     * as a shadowing barrier; it never resolves a symbol by itself. */
+    readonly lexicalNames?: ReadonlySet<string>;
+    /** Receiver names this scope BINDS rather than inherits — `this`, `self`, … (#2701).
+     *
+     *  A receiver walk (`findReceiverTypeBinding`) that reaches such a scope
+     *  without finding the name in `typeBindings` stops here and reports the
+     *  receiver unresolved, instead of continuing up and borrowing an enclosing
+     *  scope's binding. In JavaScript/TypeScript an ordinary `function` binds its
+     *  own `this` (ECMA-262 `[[ThisMode]]`) while an arrow inherits one, so
+     *  `this.m()` inside a nested `function` must NOT reach the enclosing class.
+     *
+     *  Left unset by every language whose closures capture the receiver
+     *  lexically, which is nearly all of them — the walk is unchanged there.
+     *  Populated from `LanguageProvider.scopeOwnsReceivers`. */
+    readonly ownsReceivers?: ReadonlySet<string>;
 }
 /**
  * One piece of evidence for a `Resolution`. Multiple signals corroborate a

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":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI/D,4FAA4F;AAC5F,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,0DAA0D;AAC1D,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC;AAE3B;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,GACjB,QAAQ,GACR,WAAW,GACX,OAAO,GACP,UAAU,GACV,OAAO,GACP,YAAY,GACZ,QAAQ,CAAC;AAIb,qFAAqF;AACrF,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,gCAAgC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAI7D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,YAAY;AACtB;;;;;;;GAOG;AACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;sEACkE;IAClE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;IAC5D;;;;;OAKG;IACH,QAAQ,CAAC,0BAA0B,CAAC,EAAE,OAAO,CAAC;CAC/C;AACH;;;;;;GAMG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;IAC5D,iDAAiD;IACjD,QAAQ,CAAC,0BAA0B,CAAC,EAAE,OAAO,CAAC;CAC/C;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,wFAAwF;IACxF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iCAAiC;IACjC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;GASG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AACH;;;;;;;;;;;;;;;;GAgBG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACH;;;;;;;;;;GAUG;GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEN;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,wEAAwE;IACxE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACpC;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;AAMrC;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,KAAK,GAAG,SAAS,CAAC;CAC1C;AAED,4DAA4D;AAC5D,MAAM,WAAW,QAAQ;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;iEAC6D;IAC7D,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5C;AAID;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,2DAA2D;IAC3D,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,wEAAwE;IACxE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAC7B,QAAQ,CAAC,IAAI,EACT,OAAO,GACP,OAAO,GACP,WAAW,GACX,mBAAmB,GACnB,UAAU,GACV,oBAAoB,GACpB,kBAAkB,GAClB,aAAa,CAAC;IAClB,oFAAoF;IACpF,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,4EAA4E;IAC5E,QAAQ,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC;CACpC;AAID;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC;IAC5E,sGAAsG;IACtG,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,MAAM,EACX,YAAY,GACZ,sBAAsB,GACtB,mBAAmB,GACnB,MAAM,GACN,qBAAqB,GACrB,sBAAsB,GACtB,qBAAqB,CAAC;IAC1B,iGAAiG;IACjG,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACxC;AAID;;;;;GAKG;AACH,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,mFAAmF;IACnF,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC;IAE9D,yFAAyF;IACzF,QAAQ,CAAC,SAAS,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAEhD;;kDAE8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IAExC,8FAA8F;IAC9F,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrD;AAID;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EACT,OAAO,GACP,aAAa,GACb,QAAQ,GACR,cAAc,GACd,aAAa,GACb,YAAY,GACZ,aAAa,GACb,aAAa,GACb,kBAAkB,GAClB,2BAA2B,CAAC;IAChC,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,GAAG,EAAE,gBAAgB,CAAC;IAC/B,+CAA+C;IAC/C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;IACjD,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC;AAID;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IACxB,QAAQ,CAAC,IAAI,EACT,MAAM,GACN,MAAM,GACN,OAAO,GACP,gBAAgB,GAChB,UAAU,GACV,YAAY,GACZ,WAAW,GACX,OAAO,CAAC;IACZ,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;IACnE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC,CAAC;CAChE;AAID;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC;AAE1C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,aAAa,EAAE,SAAS,SAAS,EAAE,CAAC;IAC7C,wDAAwD;IACxD,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;IACzC,QAAQ,CAAC,sBAAsB,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC5D,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;gFAE4E;IAC5E,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CACvD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}

package/dist/cli/ai-context.d.ts

@@ -5,7 +5,7 @@
  * AGENTS.md is the standard read by Cursor, Windsurf, OpenCode, Codex, Cline, CodeBuddy, Qoder, etc.
  * CLAUDE.md is for Claude Code which only reads that file.
  */
-import { type GeneratedSkillInfo } from './skill-gen.js';
+import { type GeneratedSkillInfo } from './generated-skill.js';
 interface RepoStats {
     files?: number;
     nodes?: number;
@@ -47,7 +47,8 @@ export interface GitNexusContentOptions {
     skipSkills?: boolean;
     /** Project-relative path to the runner `gitnexus analyze` drops next to the
      *  index (#1945). Referenced by docs so a single CLI-neutral command resolves
-     *  the available runner (global `gitnexus` → `pnpm dlx` → `npx`) at call time. */
+     *  the available runner (global `gitnexus` → `pnpm dlx` → `bunx` → `npx`) at
+     *  call time. */
     runnerPath?: string;
     /** Default branch for the regression-compare example (#243). Configurable so
      *  projects on `develop`/`master`/etc. don't get `base_ref: "main"` rewritten

package/dist/cli/ai-context.js

@@ -82,7 +82,11 @@ export function generateGitNexusContent(projectName, stats, opts = {}) {
     const { generatedSkills, groupNames, noStats, skipSkills, runnerPath = '.gitnexus/run.cjs', defaultBranch = 'main', hasPdg = false, } = opts;
     const generatedRows = generatedSkills && generatedSkills.length > 0
         ? generatedSkills
-            .map((s) => `| Work in the ${s.label} area (${s.symbolCount} symbols) | \`.claude/skills/${s.name}/SKILL.md\` |`)
+            .map((s) => 
+        // The per-cluster count is as volatile as the header parenthetical,
+        // so --no-stats drops it too (#2907) — otherwise the flag that
+        // promises "omit volatile symbol counts" left a churning one behind.
+        `| Work in the ${s.label} area${noStats ? '' : ` (${s.symbolCount} symbols)`} | \`.claude/skills/${s.name}/SKILL.md\` |`)
             .join('\n')
         : '';
     // Standard skill rows reference files installed by installSkills(). When
@@ -98,7 +102,7 @@ export function generateGitNexusContent(projectName, stats, opts = {}) {
     const tableBody = [standardSkillsRows, generatedRows].filter(Boolean).join('\n');
     const skillsTable = tableBody
         ? `| Task | Read this skill file |
-|------|---------------------|
+| --- | --- |
 ${tableBody}`
         : '';
     // Docs reference the project-local runner `gitnexus analyze` writes (#1945):
@@ -107,22 +111,40 @@ ${tableBody}`
     // stay under the CLAUDE.md block token budget (#856); the cli skill carries the
     // full bootstrap + npm-11 fallback (`node.target is null` npx install crash).
     const runner = `node ${runnerPath}`;
-    const bootstrapNote = `No \`${runnerPath}\` yet? \`npx gitnexus analyze\` ` +
-        '(npm 11 crash → `npm i -g gitnexus`; #1939).';
+    // Bootstrap names every install-free one-shot rather than the one this machine
+    // resolves to: the block is committed, so a host-specific command would make
+    // two contributors on different package managers rewrite it at each other on
+    // every analyze (the per-machine churn of #1706). `bunx` is listed because a
+    // bun-only machine has no npm, npx or pnpm at all, and the npx-only note left
+    // it with a bootstrap command it could not run.
+    const bootstrapNote = `No \`${runnerPath}\` yet? Bootstrap with \`npx\`, \`bunx\`, or \`pnpm dlx\` — ` +
+        'e.g. `bunx gitnexus@latest analyze` (npm 11 npx crash; #1939).';
+    // This block is injected into every user's repo and its total size is capped
+    // by test (ai-context.test.ts, #856) — a new bullet or clause has to be paid
+    // for by trimming an existing one.
+    //
+    // The detect_changes bullet carries the degraded-result rule (#2915): a run
+    // that sets `partial` (a graph query failed) or `truncated` (the changed-symbol
+    // listing was capped) is not the pre-commit gate passing, and `partial` pairs
+    // routinely with changed_count:0 — the exact shape that printed "No changes
+    // detected." and exited 0 on a broken analysis. Same reasoning as the
+    // `risk: UNKNOWN` bullet below: the tool could not answer, so its zero is not
+    // an all-clear.
     return `${GITNEXUS_START_MARKER}
 # GitNexus — Code Intelligence
 
-This project is indexed by GitNexus as **${projectName}**${noStats ? '' : ` (${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} execution flows)`}. Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
+This project is indexed by GitNexus as **${projectName}**${noStats ? '' : ` (${stats.nodes || 0} symbols, ${stats.edges || 0} relationships, ${stats.processes || 0} execution flows)`}.
 
-> Index stale? Run \`${runner} analyze\` from the project root — it auto-selects an available runner. ${bootstrapNote}
+> Index stale? Run \`${runner} analyze --index-only\` from the project root — it auto-selects an available runner. ${bootstrapNote}
 
 ## Always Do
 
-- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run \`impact({target: "symbolName", direction: "upstream"})\` and report the blast radius (direct callers, affected processes, risk level) to the user.${hasPdg
-        ? ` For unified PDG impact, add \`mode: "pdg"\` with optional \`line: <N>\` — it returns statement-level \`affectedStatements\` over CDG + REACHING_DEF and inter-procedural symbols in \`interproceduralByDepth\`/\`byDepth\`; no-layer/degraded PDG results are UNKNOWN-risk notes (\`--pdg\` layer).`
+- **MUST run impact analysis before editing.** Use \`impact({target: "symbolName", direction: "upstream"})\` (MCP) or \`${runner} impact "symbolName" --direction upstream --repo .\` (CLI fallback); report callers, processes, and risk. Never substitute grep for graph analysis.${hasPdg
+        ? ` For unified PDG impact, add \`mode: "pdg"\` with optional \`line: <N>\` — it returns statement-level \`affectedStatements\` over CDG + REACHING_DEF and inter-procedural symbols in \`interproceduralByDepth\`/\`byDepth\`; no-layer/degraded PDG results are UNKNOWN-risk notes (\`--pdg\` layer). CLI equivalent: \`${runner} impact "symbolName" --direction upstream --mode pdg --line <N> --repo .\`.`
         : ''}
-- **MUST run \`detect_changes()\` before committing** to verify your changes only affect expected symbols and execution flows. For regression review, compare against the default branch: \`detect_changes({scope: "compare", base_ref: ${JSON.stringify(markdownSafeBranch(defaultBranch))}})\`.
+- **MUST analyze graph changes before committing.** Use \`detect_changes({scope: "all"})\` (MCP) or \`${runner} detect-changes --scope all --repo .\` (CLI fallback). \`partial: true\` or \`truncated: true\` is not a clean check — a zero means unseen, not unaffected; re-run it. For regression review: \`detect_changes({scope: "compare", base_ref: ${JSON.stringify(markdownSafeBranch(defaultBranch))}})\` or \`${runner} detect-changes --scope compare --base-ref ${JSON.stringify(markdownSafeBranch(defaultBranch))} --repo .\`.
 - **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits.
+- **MUST treat \`risk: UNKNOWN\` as unresolved, not as low.** An empty caller set is not evidence the symbol is unused — it can also mean the callers are not resolvable by the index (plain-object property access, dynamic dispatch, cross-language calls). \`impact\` pairs \`UNKNOWN\` with a \`riskNote\` saying so. Confirm with a text search before treating the symbol as safe to change or delete; do not proceed on the strength of a zero.
 - When exploring unfamiliar code, use \`query({search_query: "concept"})\` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance.
 - When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use \`context({name: "symbolName"})\`.
 - For security review, \`explain({target: "fileOrSymbol"})\` lists taint findings (source→sink flows; needs \`analyze --pdg\`).${hasPdg
@@ -131,15 +153,15 @@ This project is indexed by GitNexus as **${projectName}**${noStats ? '' : ` (${s
 
 ## Never Do
 
-- NEVER edit a function, class, or method without first running \`impact\` on it.
-- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis.
+- NEVER edit a function, class, or method before MCP/CLI impact analysis.
+- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis, and never read \`UNKNOWN\` as an all-clear — it means the walk could not answer, which is the one verdict that requires confirming by other means.
 - NEVER rename symbols with find-and-replace — use \`rename\` which understands the call graph.
-- NEVER commit changes without running \`detect_changes()\` to check affected scope.
+- NEVER commit before MCP/CLI graph change analysis.
 
 ## Resources
 
 | Resource | Use for |
-|----------|---------|
+| --- | --- |
 | \`gitnexus://repo/${projectName}/context\` | Codebase overview, check index freshness |
 | \`gitnexus://repo/${projectName}/clusters\` | All functional areas |
 | \`gitnexus://repo/${projectName}/processes\` | All execution flows |
@@ -171,16 +193,40 @@ async function fileExists(filePath) {
         return false;
     }
 }
+/**
+ * Replace the block's volatile counts — the header parenthetical and the
+ * per-cluster symbol counts in the skills table — with fixed placeholders, so
+ * two renderings that differ only in those numbers compare equal.
+ *
+ * Placeholders rather than deletions: `--no-stats` REMOVES the parenthetical,
+ * which must still be written through. Deleting instead of substituting would
+ * make a with-counts block and a without-counts block compare equal, and the
+ * flag would silently stop taking effect on an already-injected file.
+ */
+function stripVolatileCounts(section) {
+    return section
+        .replace(/ \(\d+ symbols, \d+ relationships, \d+ execution flows\)/g, ' (<counts>)')
+        .replace(/ \(\d+ symbols\)/g, ' (<count>)');
+}
 /**
  * Create or update GitNexus section in a file
  * - If file doesn't exist: create with GitNexus content
  * - If file exists without GitNexus section: append
- * - If file exists with GitNexus section: replace that section
+ * - If file exists with GitNexus section: replace that section, UNLESS the only
+ *   delta is the volatile counts (#2907). AGENTS.md and CLAUDE.md are the agent
+ *   guides teams commit, and the counts move with any code change, so a
+ *   count-only rewrite dirties a tracked file on every reindex for no reader
+ *   benefit. Live counts stay available from `gitnexus status` and
+ *   `gitnexus://repo/{name}/context`; the committed block keeps whichever
+ *   numbers it was last materially updated with.
  */
 async function upsertGitNexusSection(filePath, content, projectName, stats, noStats) {
     const exists = await fileExists(filePath);
     if (!exists) {
-        await fs.writeFile(filePath, content, 'utf-8');
+        // Same `.trim() + '\n'` shape the update paths write. Creating without the
+        // trailing newline made the NEXT analyze dirty a freshly committed file
+        // even at unchanged counts, purely to append it (#2907).
+        await fs.writeFile(filePath, content.trim() + '\n', 'utf-8');
         return 'created';
     }
     const existingContent = await fs.readFile(filePath, 'utf-8');
@@ -228,6 +274,11 @@ async function upsertGitNexusSection(filePath, content, projectName, stats, noSt
             const statsPattern = /^(?:Indexed as|indexed by GitNexus as) \*\*[^*]+\*\*(?: \([^)]+\))?/m;
             if (statsPattern.test(existingSection)) {
                 const updatedSection = existingSection.replace(statsPattern, statsLine);
+                // Count-only delta — leave the committed lean block alone (#2907). A
+                // project rename, or --no-stats dropping the parenthetical, still writes.
+                if (stripVolatileCounts(updatedSection) === stripVolatileCounts(existingSection)) {
+                    return 'preserved';
+                }
                 const before = existingContent.substring(0, startIdx);
                 const after = existingContent.substring(endIdx + GITNEXUS_END_MARKER.length);
                 await fs.writeFile(filePath, (before + updatedSection + after).trim() + '\n', 'utf-8');
@@ -238,7 +289,11 @@ async function upsertGitNexusSection(filePath, content, projectName, stats, noSt
             // don't mis-report this as 'updated' (which would imply a write).
             return 'preserved';
         }
-        // No keep marker — replace existing section with full verbose content
+        // No keep marker — replace existing section with full verbose content,
+        // unless the counts are the only thing that moved (#2907).
+        if (stripVolatileCounts(existingSection) === stripVolatileCounts(content)) {
+            return 'preserved';
+        }
         const before = existingContent.substring(0, startIdx);
         const after = existingContent.substring(endIdx + GITNEXUS_END_MARKER.length);
         const newContent = before + content + after;

package/dist/cli/analyze-config.d.ts

@@ -27,7 +27,7 @@
  * documented precedence). Conflicting *aliases at the same level* (e.g. both
  * `defaultBranch` and `branch`) are rejected.
  */
-import type { AnalyzeOptions } from './analyze.js';
+import type { AnalyzeOptions } from './analyze-options.js';
 export declare const GITNEXUS_RC_FILENAME = ".gitnexusrc";
 /** Final fallback when no branch is configured or detectable. */
 export declare const DEFAULT_BRANCH_FALLBACK = "main";