gitnexus 1.6.10-rc.95 → 1.6.10-rc.96

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

@@ -63,6 +63,13 @@ export interface GitNexusContentOptions {
     hasPdg?: boolean;
 }
 export declare function generateGitNexusContent(projectName: string, stats: RepoStats, opts?: GitNexusContentOptions): string;
+/**
+ * Some agents read skills from a repo-local `.agents/skills/` directory and
+ * prefer it over the global `~/.agents/skills/` install. When the repo contains
+ * an `.agents/` directory, skills written to `.claude/skills/` are mirrored
+ * there too so those agents serve the up-to-date copies.
+ */
+export declare function shouldMirrorSkillsToAgents(repoPath: string): Promise<boolean>;
 /**
  * Generate AI context files after indexing
  */

package/dist/cli/ai-context.js

@@ -250,14 +250,31 @@ async function upsertGitNexusSection(filePath, content, projectName, stats, noSt
     await fs.writeFile(filePath, newContent, 'utf-8');
     return 'appended';
 }
+/**
+ * Some agents read skills from a repo-local `.agents/skills/` directory and
+ * prefer it over the global `~/.agents/skills/` install. When the repo contains
+ * an `.agents/` directory, skills written to `.claude/skills/` are mirrored
+ * there too so those agents serve the up-to-date copies.
+ */
+export async function shouldMirrorSkillsToAgents(repoPath) {
+    try {
+        const stat = await fs.stat(path.join(repoPath, '.agents'));
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Install GitNexus skills as direct children of .claude/skills/
- * Works natively with Claude Code, Cursor, and GitHub Copilot
+ * Works natively with Claude Code, Cursor, and GitHub Copilot.
+ * Mirrored to .agents/skills/ when .agents/ exists.
  */
 async function installSkills(repoPath) {
     const skillsDir = path.join(repoPath, '.claude', 'skills');
     const legacySkillsDir = path.join(skillsDir, 'gitnexus');
     const installedSkills = [];
+    const agentsMirror = await shouldMirrorSkillsToAgents(repoPath);
     for (const skill of STANDARD_SKILL_CATALOG.filter((entry) => entry.distributions.project && entry.distributions.npm)) {
         const skillDir = path.join(skillsDir, skill.name);
         const skillPath = path.join(skillDir, 'SKILL.md');
@@ -285,6 +302,17 @@ Use GitNexus tools to accomplish this task.
 `;
             }
             await fs.writeFile(skillPath, skillContent, 'utf-8');
+            // Mirror to .agents/skills/ for agents that read repo-local skills
+            if (agentsMirror) {
+                try {
+                    const agentsSkillDir = path.join(repoPath, '.agents', 'skills', skill.name);
+                    await fs.mkdir(agentsSkillDir, { recursive: true });
+                    await fs.writeFile(path.join(agentsSkillDir, 'SKILL.md'), skillContent, 'utf-8');
+                }
+                catch (err) {
+                    logger.warn({ err }, `Warning: Could not mirror skill ${skill.name} to .agents/skills:`);
+                }
+            }
             installedSkills.push(skill.name);
             // Previous releases installed these known standard skills one level too
             // deep. Remove only the child owned by this installer; unknown siblings
@@ -301,7 +329,7 @@ Use GitNexus tools to accomplish this task.
             logger.warn({ err }, `Warning: Could not install skill ${skill.name}:`);
         }
     }
-    return installedSkills;
+    return { skills: installedSkills, agentsMirror };
 }
 /**
  * Generate AI context files after indexing
@@ -349,9 +377,12 @@ export async function generateAIContextFiles(repoPath, storagePath, projectName,
     }
     // Install standard skills directly under .claude/skills/ (unless --skip-skills)
     if (!options?.skipSkills) {
-        const installedSkills = await installSkills(repoPath);
+        const { skills: installedSkills, agentsMirror } = await installSkills(repoPath);
         if (installedSkills.length > 0) {
             createdFiles.push(`.claude/skills/gitnexus-*/ (${installedSkills.length} skills)`);
+            if (agentsMirror) {
+                createdFiles.push(`.agents/skills/gitnexus-*/ (${installedSkills.length} skills mirrored for .agents)`);
+            }
         }
     }
     else {

package/dist/cli/i18n/en.d.ts

@@ -153,7 +153,7 @@ export declare const en: {
     readonly 'help.option.analyze.skills': "Generate repo-specific skill files from detected communities (no-op when --index-only is also set).";
     readonly 'help.option.analyze.skipAgentsMd': "Skip updating the gitnexus section in AGENTS.md and CLAUDE.md";
     readonly 'help.option.analyze.noStats': "Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md";
-    readonly 'help.option.analyze.skipSkills': "Skip installing standard GitNexus skill files directly under .claude/skills/. Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). Use --index-only to skip all AI-context file injection.";
+    readonly 'help.option.analyze.skipSkills': "Skip installing standard GitNexus skill files directly under .claude/skills/ and .agents/skills/. Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). Use --index-only to skip all AI-context file injection.";
     readonly 'help.option.analyze.indexOnly': "Pure index mode: skip all file injection (AGENTS.md, CLAUDE.md, skills)";
     readonly 'help.option.skipGit': "Treat the provided path/cwd as the index root and skip parent git-root discovery";
     readonly 'help.option.analyze.name': "Register this repo under a custom name in ~/.gitnexus/registry.json (disambiguates repos whose paths share a basename, e.g. two different .../app folders)";

package/dist/cli/i18n/en.js

@@ -153,7 +153,7 @@ export const en = {
     'help.option.analyze.skills': 'Generate repo-specific skill files from detected communities (no-op when --index-only is also set).',
     'help.option.analyze.skipAgentsMd': 'Skip updating the gitnexus section in AGENTS.md and CLAUDE.md',
     'help.option.analyze.noStats': 'Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md',
-    'help.option.analyze.skipSkills': 'Skip installing standard GitNexus skill files directly under .claude/skills/. Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). Use --index-only to skip all AI-context file injection.',
+    'help.option.analyze.skipSkills': 'Skip installing standard GitNexus skill files directly under .claude/skills/ and .agents/skills/. Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). Use --index-only to skip all AI-context file injection.',
     'help.option.analyze.indexOnly': 'Pure index mode: skip all file injection (AGENTS.md, CLAUDE.md, skills)',
     'help.option.skipGit': 'Treat the provided path/cwd as the index root and skip parent git-root discovery',
     'help.option.analyze.name': 'Register this repo under a custom name in ~/.gitnexus/registry.json (disambiguates repos whose paths share a basename, e.g. two different .../app folders)',

package/dist/cli/i18n/resources.d.ts

@@ -154,7 +154,7 @@ export declare const cliResources: {
         readonly 'help.option.analyze.skills': "Generate repo-specific skill files from detected communities (no-op when --index-only is also set).";
         readonly 'help.option.analyze.skipAgentsMd': "Skip updating the gitnexus section in AGENTS.md and CLAUDE.md";
         readonly 'help.option.analyze.noStats': "Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md";
-        readonly 'help.option.analyze.skipSkills': "Skip installing standard GitNexus skill files directly under .claude/skills/. Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). Use --index-only to skip all AI-context file injection.";
+        readonly 'help.option.analyze.skipSkills': "Skip installing standard GitNexus skill files directly under .claude/skills/ and .agents/skills/. Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). Use --index-only to skip all AI-context file injection.";
         readonly 'help.option.analyze.indexOnly': "Pure index mode: skip all file injection (AGENTS.md, CLAUDE.md, skills)";
         readonly 'help.option.skipGit': "Treat the provided path/cwd as the index root and skip parent git-root discovery";
         readonly 'help.option.analyze.name': "Register this repo under a custom name in ~/.gitnexus/registry.json (disambiguates repos whose paths share a basename, e.g. two different .../app folders)";

package/dist/cli/i18n/zh-CN.js

@@ -153,7 +153,7 @@ export const zhCN = {
     'help.option.analyze.skills': '根据检测到的社区生成仓库专属 skill 文件（同时设置 --index-only 时无效）。',
     'help.option.analyze.skipAgentsMd': '跳过更新 AGENTS.md 和 CLAUDE.md 中的 gitnexus 区块',
     'help.option.analyze.noStats': '从 AGENTS.md 和 CLAUDE.md 中省略易变的文件/符号计数',
-    'help.option.analyze.skipSkills': '跳过直接安装在 .claude/skills/ 下的标准 GitNexus skill 文件。不抑制 --skills 生成的社区 skill（位于 .claude/skills/gitnexus-area-*）。使用 --index-only 可跳过所有 AI 上下文文件注入。',
+    'help.option.analyze.skipSkills': '跳过直接安装在 .claude/skills/ 和 .agents/skills/ 下的标准 GitNexus skill 文件。不抑制 --skills 生成的社区 skill（位于 .claude/skills/gitnexus-area-*）。使用 --index-only 可跳过所有 AI 上下文文件注入。',
     'help.option.analyze.indexOnly': '纯索引模式：跳过所有文件注入（AGENTS.md、CLAUDE.md、skills）',
     'help.option.skipGit': '将提供的路径/cwd 视为索引根目录，并跳过向上查找 git 根目录',
     'help.option.analyze.name': '在 ~/.gitnexus/registry.json 中使用自定义名称注册该仓库（用于区分路径 basename 相同的仓库，例如两个不同的 .../app 目录）',

package/dist/cli/index.js

@@ -53,7 +53,7 @@ program
     'Without this flag, analyze always updates the workspace index, which follows the ' +
     'checked-out working tree. Distinct from --default-branch (cosmetic base_ref).')
     .option('--no-stats', 'Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md')
-    .option('--skip-skills', 'Skip installing standard GitNexus skill files directly under .claude/skills/. ' +
+    .option('--skip-skills', 'Skip installing standard GitNexus skill files directly under .claude/skills/ and .agents/skills/. ' +
     'Does not suppress community skills from --skills (those use .claude/skills/gitnexus-area-*). ' +
     'Use --index-only to skip all AI-context file injection.')
     .option('--index-only', 'Pure index mode: skip all file injection (AGENTS.md, CLAUDE.md, skills)')

package/dist/cli/skill-gen.js

@@ -8,6 +8,7 @@
  */
 import fs from 'fs/promises';
 import path from 'path';
+import { shouldMirrorSkillsToAgents } from './ai-context.js';
 const GENERATED_SKILL_PREFIX = 'gitnexus-area-';
 const MAX_SKILL_NAME_LENGTH = 64;
 const MAX_COMMUNITY_NAME_LENGTH = MAX_SKILL_NAME_LENGTH - GENERATED_SKILL_PREFIX.length;
@@ -25,6 +26,12 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
     const { communityResult, processResult, graph } = pipelineResult;
     const outputDir = path.join(repoPath, '.claude', 'skills');
     const legacyOutputDir = path.join(outputDir, 'generated');
+    // Some agents prioritize repo-local .agents/skills over the global
+    // ~/.agents/skills install (see shouldMirrorSkillsToAgents). When .agents/
+    // exists, mirror the generated community skills there too so those agents
+    // serve the up-to-date copies.
+    const agentsOutputDir = path.join(repoPath, '.agents', 'skills');
+    let mirrorToAgents = await shouldMirrorSkillsToAgents(repoPath);
     // Community skills used to live under an undiscoverable `generated/`
     // grouping directory. Clear that GitNexus-owned legacy output and
     // stale direct outputs in the reserved namespace, while preserving every
@@ -44,6 +51,20 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
     catch {
         /* legacy output may not exist */
     }
+    // Mirror cleanup: clear only stale GitNexus-generated community skills under
+    // .agents/skills/ (reserved gitnexus-area-* namespace), preserving mirrored
+    // standard skills and any user-authored skills. Never clear the whole root.
+    if (mirrorToAgents) {
+        try {
+            const entries = await fs.readdir(agentsOutputDir, { withFileTypes: true });
+            await Promise.all(entries
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith(GENERATED_SKILL_PREFIX))
+                .map((entry) => fs.rm(path.join(agentsOutputDir, entry.name), { recursive: true, force: true })));
+        }
+        catch {
+            /* mirror root may not exist yet */
+        }
+    }
     if (!communityResult || !communityResult.memberships.length) {
         console.log('\n  Skills: no communities detected, skipping skill generation');
         return { skills: [], outputPath: outputDir };
@@ -73,6 +94,19 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
     // Step 4: Ensure the shared project-skill root exists. Never clear it: it
     // also contains user-authored and standard GitNexus skills.
     await fs.mkdir(outputDir, { recursive: true });
+    // The .agents/ mirror is a side flow: keep it a weak dependency. If the
+    // mirror root cannot be created (e.g. `.agents/skills` exists as a file),
+    // warn and disable mirroring for this run instead of aborting canonical
+    // community-skill generation. Canonical writes below stay unaffected.
+    if (mirrorToAgents) {
+        try {
+            await fs.mkdir(agentsOutputDir, { recursive: true });
+        }
+        catch (err) {
+            console.log(`Warning: Could not create mirror root ${agentsOutputDir} — .agents/skills mirroring disabled for this run: ${err}`);
+            mirrorToAgents = false;
+        }
+    }
     // Step 5: Generate skill files
     const skills = [];
     const usedNames = new Set();
@@ -99,6 +133,19 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
         const skillDir = path.join(outputDir, skillName);
         await fs.mkdir(skillDir, { recursive: true });
         await fs.writeFile(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
+        // Mirror to .agents/skills/ for agents that read repo-local skills
+        // (see mirrorToAgents above). Best-effort: a per-skill mirror failure
+        // must not abort canonical community-skill generation.
+        if (mirrorToAgents) {
+            try {
+                const agentsSkillDir = path.join(agentsOutputDir, skillName);
+                await fs.mkdir(agentsSkillDir, { recursive: true });
+                await fs.writeFile(path.join(agentsSkillDir, 'SKILL.md'), content, 'utf-8');
+            }
+            catch (err) {
+                console.log(`Warning: Could not mirror skill ${skillName} to .agents/skills: ${err}`);
+            }
+        }
         const info = {
             name: skillName,
             label: community.label,
@@ -109,6 +156,9 @@ export const generateSkillFiles = async (repoPath, projectName, pipelineResult)
         console.log(`    \u2713 ${community.label} (${community.symbolCount} symbols, ${files.length} files)`);
     }
     console.log(`\n  ${skills.length} skills generated \u2192 .claude/skills/${GENERATED_SKILL_PREFIX}*/`);
+    if (mirrorToAgents) {
+        console.log(`  ${skills.length} skills mirrored \u2192 .agents/skills/${GENERATED_SKILL_PREFIX}*/ (.agents)`);
+    }
     return { skills, outputPath: outputDir };
 };
 // ============================================================================

package/dist/core/ingestion/languages/rust/range-binding.d.ts

@@ -1,16 +1,6 @@
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
-/**
- * Populate type bindings for patterns and iterators that the tree-sitter
- * query can't handle (they need runtime type lookup, not just syntax).
- *
- * Covers: for-loop element types, if-let/while-let pattern bindings,
- * match arm patterns, and struct destructuring.
- *
- * Runs in Phase 2 (after propagateImportedReturnTypes) so all cross-file
- * type bindings are available for lookup.
- */
-export declare function populateRustRangeBindings(parsedFiles: readonly ParsedFile[], _indexes: ScopeResolutionIndexes, ctx: {
+export declare function populateRustRangeBindings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
     readonly fileContents: ReadonlyMap<string, string>;
     readonly treeCache?: {
         get(filePath: string): unknown;

package/dist/core/ingestion/languages/rust/range-binding.js

@@ -2,54 +2,84 @@ import { getRustParser } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
 import { logger } from '../../../logger.js';
+import { lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
 /**
- * Populate type bindings for patterns and iterators that the tree-sitter
- * query can't handle (they need runtime type lookup, not just syntax).
- *
- * Covers: for-loop element types, if-let/while-let pattern bindings,
- * match arm patterns, and struct destructuring.
- *
- * Runs in Phase 2 (after propagateImportedReturnTypes) so all cross-file
- * type bindings are available for lookup.
+ * Hold parsed trees for reuse across both prepass loops only when the whole
+ * Rust source fits this budget. Trees are much larger than their source, so a
+ * modest source cap keeps peak held-tree memory bounded; larger repos fall
+ * back to re-parsing per loop (unchanged RSS).
  */
-export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
+const TREE_REUSE_SOURCE_BUDGET_BYTES = 16 * 1024 * 1024;
+/**
+ * Parse `filePath`'s source once, honoring the caller's `treeCache` and, when
+ * provided, an in-function `store` so the two prepass loops share a single
+ * parse instead of re-parsing every file. Returns null when the source is
+ * missing or parsing times out.
+ */
+function getOrParseTree(parser, filePath, ctx, store) {
+    const cached = (ctx.treeCache?.get(filePath) ?? store?.get(filePath));
+    if (cached !== undefined)
+        return cached;
+    const sourceText = ctx.fileContents.get(filePath);
+    if (sourceText === undefined)
+        return null;
+    let tree;
+    try {
+        tree = parseSourceSafe(parser, sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
+    }
+    catch (err) {
+        if (err instanceof ParseTimeoutError) {
+            logger.warn({ file: filePath }, 'rust range-binding: parse timed out, skipping file');
+            return null;
+        }
+        throw err;
+    }
+    store?.set(filePath, tree);
+    return tree;
+}
+export function populateRustRangeBindings(parsedFiles, indexes, ctx) {
     const parser = getRustParser();
     const allReturnTypes = new Map();
+    const ambiguousReturnTypes = new Set();
     const allFieldTypes = new Map();
+    const ambiguousFieldTypes = new Set();
+    // Per-defining-file, un-collapsed, FULL-generic return/field types. When a
+    // bare name is ambiguous (#2514) but the call site's `use` import pins a
+    // single definition, we resolve that definition's file here and read its
+    // untruncated type so a generic `Vec<Repo>` element type survives (#2514
+    // follow-up: import-disambiguated duplicates resolve like the compiler).
+    const returnTypeByFile = new Map();
+    const fieldTypeByFile = new Map();
+    // Parse each file once and reuse across both loops when the workspace fits
+    // the byte budget; otherwise re-parse per loop to bound RSS (see helper).
+    let totalSourceBytes = 0;
     for (const parsed of parsedFiles) {
-        const sourceText = ctx.fileContents.get(parsed.filePath);
-        if (sourceText === undefined)
+        totalSourceBytes += ctx.fileContents.get(parsed.filePath)?.length ?? 0;
+    }
+    const treeStore = totalSourceBytes <= TREE_REUSE_SOURCE_BUDGET_BYTES ? new Map() : undefined;
+    for (const parsed of parsedFiles) {
+        const tree = getOrParseTree(parser, parsed.filePath, ctx, treeStore);
+        if (tree === null)
             continue;
-        const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        let tree;
-        if (cachedTree !== undefined) {
-            tree = cachedTree;
-        }
-        else {
-            try {
-                tree = parseSourceSafe(parser, sourceText, undefined, {
-                    bufferSize: getTreeSitterBufferSize(sourceText),
-                });
-            }
-            catch (err) {
-                if (err instanceof ParseTimeoutError) {
-                    logger.warn({ file: parsed.filePath }, 'rust range-binding: parse timed out, skipping file');
-                    continue;
-                }
-                throw err;
-            }
-        }
         for (const fn of tree.rootNode.descendantsOfType('function_item')) {
             const nameNode = fn.childForFieldName('name');
             const retType = fn.childForFieldName('return_type');
             if (nameNode !== null && retType !== null) {
                 const name = nameNode.text;
+                // Ambiguity is a latch, not a toggle: once a name has two or more
+                // workspace definitions it stays ambiguous for the rest of the
+                // prepass, regardless of duplicate count or file order (#2514).
                 if (allReturnTypes.has(name)) {
                     allReturnTypes.delete(name);
+                    ambiguousReturnTypes.add(name);
                 }
-                else {
+                else if (!ambiguousReturnTypes.has(name)) {
                     allReturnTypes.set(name, retType.text);
                 }
+                // Full-generic record per defining file for import-disambiguated lookup.
+                recordByFile(returnTypeByFile, parsed.filePath, name, retType.text);
             }
         }
         for (const structNode of tree.rootNode.descendantsOfType('struct_item')) {
@@ -67,12 +97,17 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
             }
             if (fields.size > 0) {
                 const name = nameNode.text;
+                // Same ambiguity latch as return types (#2514): a third same-named
+                // struct must not restore a resolvable global field map.
                 if (allFieldTypes.has(name)) {
                     allFieldTypes.delete(name);
+                    ambiguousFieldTypes.add(name);
                 }
-                else {
+                else if (!ambiguousFieldTypes.has(name)) {
                     allFieldTypes.set(name, fields);
                 }
+                // Full-generic record per defining file for import-disambiguated lookup.
+                recordByFile(fieldTypeByFile, parsed.filePath, name, fields);
             }
         }
         // Publish per-type member bindings for the whole workspace before resolving
@@ -83,35 +118,16 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
         processIdentityMethodBindings(parsed);
     }
     for (const parsed of parsedFiles) {
-        const sourceText = ctx.fileContents.get(parsed.filePath);
-        if (sourceText === undefined)
+        const tree = getOrParseTree(parser, parsed.filePath, ctx, treeStore);
+        if (tree === null)
             continue;
-        const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        let tree;
-        if (cachedTree !== undefined) {
-            tree = cachedTree;
-        }
-        else {
-            try {
-                tree = parseSourceSafe(parser, sourceText, undefined, {
-                    bufferSize: getTreeSitterBufferSize(sourceText),
-                });
-            }
-            catch (err) {
-                if (err instanceof ParseTimeoutError) {
-                    logger.warn({ file: parsed.filePath }, 'rust range-binding: parse timed out, skipping file');
-                    continue;
-                }
-                throw err;
-            }
-        }
         const scopeMap = new Map(parsed.scopes.map((s) => [s.id, s]));
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
-        processForLoops(tree.rootNode, parsed, scopeMap, moduleScope, allReturnTypes);
+        processForLoops(tree.rootNode, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile);
         processPatternBindings(tree.rootNode, parsed, scopeMap, moduleScope);
-        processStructDestructuring(tree.rootNode, parsed, scopeMap, moduleScope, allFieldTypes);
+        processStructDestructuring(tree.rootNode, parsed, scopeMap, moduleScope, allFieldTypes, indexes, fieldTypeByFile);
         processPendingAssignments(tree.rootNode, parsed, parsedFiles, scopeMap, moduleScope, allReturnTypes);
     }
 }
@@ -158,7 +174,60 @@ function normalizeFieldType(text) {
         t = t.slice(lastColon + 2);
     return t.trim();
 }
-function processForLoops(root, parsed, scopeMap, moduleScope, allReturnTypes) {
+/** Get-or-create the inner map for `file` and record `name -> value`. */
+function recordByFile(byFile, file, name, value) {
+    let inner = byFile.get(file);
+    if (inner === undefined) {
+        inner = new Map();
+        byFile.set(file, inner);
+    }
+    inner.set(name, value);
+}
+/** Final segment of a dot-joined qualified name (`a.make` -> `make`), or the
+ *  bare name when the def carries no qualifier. */
+function simpleName(qualifiedName, bareName) {
+    if (qualifiedName === undefined)
+        return bareName;
+    const dot = qualifiedName.lastIndexOf('.');
+    return dot === -1 ? qualifiedName : qualifiedName.slice(dot + 1);
+}
+/** Distinct `(file, name)` definitions, in first-seen order. */
+function uniqueDefs(defs) {
+    const seen = new Set();
+    const out = [];
+    for (const d of defs) {
+        const key = `${d.file} ${d.name}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(d);
+    }
+    return out;
+}
+/**
+ * Resolve `name` at `moduleScope` to the value recorded in `byFile` for the one
+ * definition visible here, or null when zero or several are visible (which
+ * keeps the #2514 ambiguity latch). Mirrors Rust name resolution: explicit
+ * `use`/re-export imports and local defs shadow `use x::*` globs, so a glob is
+ * consulted only when no explicit binding names `name`, and even then only when
+ * exactly one glob-target file actually defines it.
+ */
+function resolveImportedDef(name, moduleScope, indexes, byFile) {
+    const explicit = uniqueDefs(lookupBindingsAt(moduleScope.id, name, indexes)
+        .filter((r) => r.origin === 'import' || r.origin === 'reexport' || r.origin === 'local')
+        .map((r) => ({ file: r.def.filePath, name: simpleName(r.def.qualifiedName, name) })));
+    const defs = explicit.length > 0
+        ? explicit
+        : uniqueDefs((indexes.imports.get(moduleScope.id) ?? [])
+            .filter((e) => e.kind === 'wildcard-expanded' &&
+            e.targetFile !== null &&
+            byFile.get(e.targetFile)?.has(name) === true)
+            .map((e) => ({ file: e.targetFile, name })));
+    if (defs.length !== 1)
+        return null;
+    return byFile.get(defs[0].file)?.get(defs[0].name) ?? null;
+}
+function processForLoops(root, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile) {
     for (const forNode of root.descendantsOfType('for_expression')) {
         const patternNode = forNode.childForFieldName('pattern');
         const valueNode = forNode.childForFieldName('value');
@@ -167,7 +236,7 @@ function processForLoops(root, parsed, scopeMap, moduleScope, allReturnTypes) {
         const varName = extractVarName(patternNode);
         if (varName === null)
             continue;
-        const elementType = resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes);
+        const elementType = resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile);
         if (elementType === null)
             continue;
         const targetScope = findEnclosingFunctionScope(forNode, scopeMap) ?? moduleScope;
@@ -251,7 +320,7 @@ function processTupleStructPattern(patternNode, contextNode, parsed, scopeMap, m
     const targetScope = findEnclosingFunctionScope(contextNode, scopeMap) ?? moduleScope;
     injectTypeBinding(targetScope, varName, resolvedType);
 }
-function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFieldTypes) {
+function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFieldTypes, indexes, fieldTypeByFile) {
     for (const letNode of root.descendantsOfType('let_declaration')) {
         const patternNode = letNode.childForFieldName('pattern');
         if (patternNode === null || patternNode.type !== 'struct_pattern')
@@ -274,7 +343,13 @@ function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFiel
                 continue;
             let fieldType = lookupFieldType(typeName, fieldName, parsed, scopeMap, moduleScope);
             if (fieldType === null) {
-                fieldType = allFieldTypes?.get(typeName)?.get(fieldName) ?? null;
+                fieldType = allFieldTypes.get(typeName)?.get(fieldName) ?? null;
+            }
+            if (fieldType === null) {
+                // Import-disambiguated duplicate struct (#2514 follow-up): the global
+                // field map is ambiguous, but a `use` import pins one definition.
+                const fields = resolveImportedDef(typeName, moduleScope, indexes, fieldTypeByFile);
+                fieldType = fields?.get(fieldName) ?? null;
             }
             if (fieldType !== null) {
                 injectTypeBinding(targetScope, fieldName, fieldType);
@@ -367,7 +442,7 @@ function processPendingAssignments(root, parsed, allParsedFiles, scopeMap, modul
         }
     }
 }
-function resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes) {
+function resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile) {
     let iterableNode = valueNode;
     if (iterableNode.type === 'reference_expression') {
         iterableNode = iterableNode.firstNamedChild ?? iterableNode;
@@ -390,12 +465,19 @@ function resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, al
             }
         }
         if (func.type === 'identifier') {
-            const crossFileReturn = allReturnTypes?.get(func.text);
+            const crossFileReturn = allReturnTypes.get(func.text);
             if (crossFileReturn !== undefined)
                 return unwrapGeneric(crossFileReturn);
             const rawReturn = lookupRawFunctionReturnType(func.text, valueNode);
             if (rawReturn !== null)
                 return unwrapGeneric(rawReturn);
+            // Import-disambiguated duplicate: the bare-name map is ambiguous (#2514)
+            // but a `use` import pins one definition. Read its FULL return type
+            // here, BEFORE the scope-binding lookup below, because that binding is
+            // generic-truncated (`Vec<Repo>` becomes `Vec`), losing the element.
+            const importedReturn = resolveImportedDef(func.text, moduleScope, indexes, returnTypeByFile);
+            if (importedReturn !== null)
+                return unwrapGeneric(importedReturn);
             const returnType = lookupReturnTypeInScopes(func.text, parsed, scopeMap, moduleScope);
             if (returnType !== null)
                 return unwrapGeneric(returnType);

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -420,6 +420,7 @@ export function runScopeResolution(input, provider) {
     if (provider.propagatesReturnTypesAcrossImports !== false) {
         propagateImportedReturnTypes(parsedFiles, indexes, workspaceIndex);
     }
+    const tRangeBindStart = PROF ? process.hrtime.bigint() : 0n;
     if (provider.populateRangeBindings !== undefined) {
         provider.populateRangeBindings(parsedFiles, indexes, {
             fileContents: getFileContents(),
@@ -908,6 +909,7 @@ export function runScopeResolution(input, provider) {
         logger.warn(`[scope-resolution prof] extract=${ns(tStart, tExtract).toFixed(0)}ms` +
             ` finalize=${ns(tExtract, tFinalize).toFixed(0)}ms` +
             ` propagate=${ns(tFinalize, tPropagate).toFixed(0)}ms` +
+            ` rangeBind=${ns(tRangeBindStart, tPropagate).toFixed(1)}ms` +
             ` resolve=${ns(tPropagate, tResolve).toFixed(0)}ms` +
             ` emit=${ns(tResolve, tEnd).toFixed(0)}ms` +
             // pdg ⊆ emit: the M2 reaching-defs share of the emit bucket (#2082 U4).

package/dist/storage/git.d.ts

@@ -1,10 +1,13 @@
 /**
  * True when the working tree has uncommitted changes that analyze would
  * re-index, even at a matching HEAD. Excludes the paths GitNexus writes during
- * analyze (.gitnexus/, .claude/, .cursor/, AGENTS.md, CLAUDE.md) so its own
- * output never counts as dirty (regression vs PR #1233 behavior). Conservative
- * on any git failure. Shared so `analyze`'s fast-path gate and `status`'s
- * freshness report agree on what "dirty" means.
+ * analyze (.gitnexus/, .claude/, .cursor/, AGENTS.md, CLAUDE.md, and the
+ * repo-local .agents/ mirror) so its own output never counts as dirty
+ * (regression vs PR #1233 behavior). The entire .agents/ tree is excluded,
+ * matching the .claude/ treatment, because the skill mirror writes across
+ * .agents/skills/ and deeper paths. Conservative on any git failure. Shared
+ * so `analyze`'s fast-path gate and `status`'s freshness report agree on what
+ * "dirty" means.
  */
 export declare const isWorkingTreeDirty: (repoPath: string) => boolean;
 export declare const isGitRepo: (repoPath: string) => boolean;

package/dist/storage/git.js

@@ -7,10 +7,13 @@ const chompGitOutput = (value) => value.toString().replace(/\r?\n$/, '');
 /**
  * True when the working tree has uncommitted changes that analyze would
  * re-index, even at a matching HEAD. Excludes the paths GitNexus writes during
- * analyze (.gitnexus/, .claude/, .cursor/, AGENTS.md, CLAUDE.md) so its own
- * output never counts as dirty (regression vs PR #1233 behavior). Conservative
- * on any git failure. Shared so `analyze`'s fast-path gate and `status`'s
- * freshness report agree on what "dirty" means.
+ * analyze (.gitnexus/, .claude/, .cursor/, AGENTS.md, CLAUDE.md, and the
+ * repo-local .agents/ mirror) so its own output never counts as dirty
+ * (regression vs PR #1233 behavior). The entire .agents/ tree is excluded,
+ * matching the .claude/ treatment, because the skill mirror writes across
+ * .agents/skills/ and deeper paths. Conservative on any git failure. Shared
+ * so `analyze`'s fast-path gate and `status`'s freshness report agree on what
+ * "dirty" means.
  */
 export const isWorkingTreeDirty = (repoPath) => {
     try {
@@ -27,6 +30,8 @@ export const isWorkingTreeDirty = (repoPath) => {
             ':(exclude).cursor/**',
             ':(exclude)AGENTS.md',
             ':(exclude)CLAUDE.md',
+            ':(exclude).agents',
+            ':(exclude).agents/**',
         ], {
             cwd: repoPath,
             stdio: ['ignore', 'pipe', 'ignore'],

package/dist/storage/repo-manager.d.ts

@@ -418,8 +418,21 @@ export interface RepoMeta {
  * incremental write set only covers changed files, so a top-up against a
  * pre-v11 index would keep silently missing these CALLS edges for every
  * unchanged Rust trait file; force a full re-analyze instead.
- */
-export declare const INCREMENTAL_SCHEMA_VERSION = 11;
+ * v12: Rust range-binding stopped restoring ambiguous duplicate type names
+ * (#2514): a function/struct name defined three or more times used to
+ * re-resolve to the last-scanned file (a presence toggle), so odd duplicate
+ * counts emitted a wrong cross-file CALLS edge. Same v7/v11 contract: the
+ * incremental write set only covers changed files, so a top-up against a
+ * pre-v12 index would keep these spurious CALLS edges on every unchanged Rust
+ * file. v12 also changes edges in the other direction: range-binding now
+ * RESOLVES import-disambiguated duplicate names (`for item in make()` /
+ * `let Struct { f } = ..` where a `use` or `use x::*` import pins one of several
+ * same-named definitions) to the imported definition's type. Both the removed
+ * spurious edges and these new resolved edges are cross-file, so a pre-v12
+ * top-up would leave unchanged Rust files stale either way; force a full
+ * re-analyze instead.
+ */
+export declare const INCREMENTAL_SCHEMA_VERSION = 12;
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;

package/dist/storage/repo-manager.js

@@ -139,8 +139,21 @@ export const cloneDirBelongsToEntry = (cloneDir, entryPath) => registryPathEqual
  * incremental write set only covers changed files, so a top-up against a
  * pre-v11 index would keep silently missing these CALLS edges for every
  * unchanged Rust trait file; force a full re-analyze instead.
+ * v12: Rust range-binding stopped restoring ambiguous duplicate type names
+ * (#2514): a function/struct name defined three or more times used to
+ * re-resolve to the last-scanned file (a presence toggle), so odd duplicate
+ * counts emitted a wrong cross-file CALLS edge. Same v7/v11 contract: the
+ * incremental write set only covers changed files, so a top-up against a
+ * pre-v12 index would keep these spurious CALLS edges on every unchanged Rust
+ * file. v12 also changes edges in the other direction: range-binding now
+ * RESOLVES import-disambiguated duplicate names (`for item in make()` /
+ * `let Struct { f } = ..` where a `use` or `use x::*` import pins one of several
+ * same-named definitions) to the imported definition's type. Both the removed
+ * spurious edges and these new resolved edges are cross-file, so a pre-v12
+ * top-up would leave unchanged Rust files stale either way; force a full
+ * re-analyze instead.
  */
-export const INCREMENTAL_SCHEMA_VERSION = 11;
+export const INCREMENTAL_SCHEMA_VERSION = 12;
 const GITNEXUS_DIR = '.gitnexus';
 const GITNEXUS_EXCLUDE_ENTRY = `${GITNEXUS_DIR}/`;
 export const INDEX_METADATA_FILE = 'gitnexus.json';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.95",
+  "version": "1.6.10-rc.96",
   "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",