gitnexus 1.6.11-rc.26 → 1.6.11-rc.28

package/README.md

@@ -240,7 +240,7 @@ gitnexus analyze --force         # Full rebuild: re-parse + graph rebuild + FTS
 gitnexus analyze --embeddings    # Enable embedding generation (slower, better search)
 gitnexus embeddings install      # Fetch the optional local embedding stack on demand (--cuda, --force)
 gitnexus analyze --skills        # Generate repo-specific skill files from detected communities
-gitnexus analyze --skip-agents-md  # Preserve custom AGENTS.md/CLAUDE.md gitnexus section edits
+gitnexus analyze --skip-agents-md  # Preserve custom AGENTS.md/CLAUDE.md gitnexus section edits (does not skip standard skills; use --skip-skills; community --skills files are unaffected)
 gitnexus analyze --skip-skills   # Skip installing standard .claude/skills/gitnexus-* skill files
 gitnexus analyze --skip-git      # Index folders that are not Git repositories
 gitnexus analyze --workers <n>   # Parse worker pool size (>=1; default: cores-1, capped at 16)

package/dist/cli/ai-context.js

@@ -9,6 +9,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { STANDARD_SKILL_CATALOG } from './standard-skills.js';
+import { isEnoent } from './editor-targets.js';
 import { logger } from '../core/logger.js';
 // ESM equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -321,6 +322,55 @@ export async function shouldMirrorSkillsToAgents(repoPath) {
         return false;
     }
 }
+const SKILL_PRESERVE_HINT = 'delete the file to refresh from the bundled template, or pass --skip-skills to skip skill install';
+async function readUtf8IfPresent(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return null;
+        throw err;
+    }
+}
+function skillBytesDiverge(existing, bundled) {
+    return existing !== null && existing !== bundled;
+}
+/** Write bundled skill bytes unless an existing file already differs. */
+async function writeSkillUnlessDivergent(filePath, content) {
+    const existing = await readUtf8IfPresent(filePath);
+    if (skillBytesDiverge(existing, content)) {
+        logger.warn(`Preserved customized skill ${filePath}; ${SKILL_PRESERVE_HINT}.`);
+        return true;
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+    return false;
+}
+async function inspectLegacySkillDir(legacyDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(legacyDir);
+    }
+    catch (err) {
+        if (isEnoent(err))
+            return null;
+        throw err;
+    }
+    const nestedExisting = entries.includes('SKILL.md')
+        ? await fs.readFile(path.join(legacyDir, 'SKILL.md'), 'utf-8')
+        : null;
+    return {
+        nestedExisting,
+        hasSiblings: entries.some((entry) => entry !== 'SKILL.md'),
+    };
+}
+function formatSkillInstallLine(prefix, total, preserved, allWrittenSuffix, partialSuffix) {
+    if (preserved > 0) {
+        return `${prefix} (${total - preserved} written, ${preserved} ${partialSuffix})`;
+    }
+    return `${prefix} (${total} ${allWrittenSuffix})`;
+}
 /**
  * Install GitNexus skills as direct children of .claude/skills/
  * Works natively with Claude Code, Cursor, and GitHub Copilot.
@@ -330,13 +380,14 @@ async function installSkills(repoPath) {
     const skillsDir = path.join(repoPath, '.claude', 'skills');
     const legacySkillsDir = path.join(skillsDir, 'gitnexus');
     const installedSkills = [];
+    let claudePreserved = 0;
+    let agentsPreserved = 0;
+    let legacyPreserved = 0;
     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');
         try {
-            // Create skill directory
-            await fs.mkdir(skillDir, { recursive: true });
             // Try to read from package skills directory
             const packageSkillPath = path.join(__dirname, '..', '..', 'skills', `${skill.name}.md`);
             let skillContent;
@@ -357,13 +408,14 @@ ${skill.fallbackDescription}
 Use GitNexus tools to accomplish this task.
 `;
             }
-            await fs.writeFile(skillPath, skillContent, 'utf-8');
+            if (await writeSkillUnlessDivergent(skillPath, skillContent))
+                claudePreserved += 1;
             // 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');
+                    const agentsSkillPath = path.join(repoPath, '.agents', 'skills', skill.name, 'SKILL.md');
+                    if (await writeSkillUnlessDivergent(agentsSkillPath, skillContent))
+                        agentsPreserved += 1;
                 }
                 catch (err) {
                     logger.warn({ err }, `Warning: Could not mirror skill ${skill.name} to .agents/skills:`);
@@ -374,7 +426,20 @@ Use GitNexus tools to accomplish this task.
             // deep. Remove only the child owned by this installer; unknown siblings
             // under the legacy grouping directory may be user-authored and survive.
             try {
-                await fs.rm(path.join(legacySkillsDir, skill.name), { recursive: true, force: true });
+                const legacyDir = path.join(legacySkillsDir, skill.name);
+                const nestedSkill = path.join(legacyDir, 'SKILL.md');
+                const leftover = await inspectLegacySkillDir(legacyDir);
+                if (leftover !== null && skillBytesDiverge(leftover.nestedExisting, skillContent)) {
+                    logger.warn(`Preserved customized skill ${nestedSkill}; ${SKILL_PRESERVE_HINT}.`);
+                    legacyPreserved += 1;
+                }
+                else if (leftover?.hasSiblings) {
+                    logger.warn(`Preserved legacy skill directory ${legacyDir} because it contains operator-owned files.`);
+                    legacyPreserved += 1;
+                }
+                else if (leftover !== null) {
+                    await fs.rm(legacyDir, { recursive: true, force: true });
+                }
             }
             catch (err) {
                 logger.warn({ err }, `Warning: Could not remove legacy skill ${skill.name}:`);
@@ -385,7 +450,13 @@ Use GitNexus tools to accomplish this task.
             logger.warn({ err }, `Warning: Could not install skill ${skill.name}:`);
         }
     }
-    return { skills: installedSkills, agentsMirror };
+    return {
+        skills: installedSkills,
+        agentsMirror,
+        claudePreserved,
+        agentsPreserved,
+        legacyPreserved,
+    };
 }
 /**
  * Generate AI context files after indexing
@@ -434,11 +505,14 @@ export async function generateAIContextFiles(repoPath, storagePath, projectName,
     }
     // Install standard skills directly under .claude/skills/ (unless --skip-skills)
     if (!options?.skipSkills) {
-        const { skills: installedSkills, agentsMirror } = await installSkills(repoPath);
+        const { skills: installedSkills, agentsMirror, claudePreserved, agentsPreserved, legacyPreserved, } = await installSkills(repoPath);
         if (installedSkills.length > 0) {
-            createdFiles.push(`.claude/skills/gitnexus-*/ (${installedSkills.length} skills)`);
+            createdFiles.push(formatSkillInstallLine('.claude/skills/gitnexus-*/', installedSkills.length, claudePreserved, 'skills', 'preserved'));
             if (agentsMirror) {
-                createdFiles.push(`.agents/skills/gitnexus-*/ (${installedSkills.length} skills mirrored for .agents)`);
+                createdFiles.push(formatSkillInstallLine('.agents/skills/gitnexus-*/', installedSkills.length, agentsPreserved, 'skills mirrored for .agents', 'preserved for .agents'));
+            }
+            if (legacyPreserved > 0) {
+                createdFiles.push(`.claude/skills/gitnexus/<name>/ (legacy directories preserved: ${legacyPreserved})`);
             }
         }
     }

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

@@ -162,7 +162,7 @@ export declare const en: {
     readonly 'help.option.analyze.embeddings': "Enable embedding generation for semantic search (off by default). Optional [limit] overrides the 50,000-node safety cap; pass 0 to disable the cap entirely.";
     readonly 'help.option.analyze.dropEmbeddings': "Drop existing embeddings on rebuild. By default, an `analyze` without `--embeddings` preserves any embeddings already present in the index.";
     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.skipAgentsMd': "Skip updating the gitnexus section in AGENTS.md and CLAUDE.md. Does not skip standard skills in .claude/skills or .agents/skills; use --skip-skills for those. Community skills from --skills are unaffected.";
     readonly 'help.option.analyze.noStats': "Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md";
     readonly 'help.option.analyze.selfCommit': "Auto-commit AGENTS.md/CLAUDE.md changes after analyze (opt-in, off by default). Scoped to only those two files (never `git add -A`); no-ops if neither exists, neither changed, or the repo has no git identity configured.";
     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.";

package/dist/cli/i18n/en.js

@@ -164,7 +164,7 @@ export const en = {
     'help.option.analyze.embeddings': 'Enable embedding generation for semantic search (off by default). Optional [limit] overrides the 50,000-node safety cap; pass 0 to disable the cap entirely.',
     'help.option.analyze.dropEmbeddings': 'Drop existing embeddings on rebuild. By default, an `analyze` without `--embeddings` preserves any embeddings already present in the index.',
     '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.skipAgentsMd': 'Skip updating the gitnexus section in AGENTS.md and CLAUDE.md. Does not skip standard skills in .claude/skills or .agents/skills; use --skip-skills for those. Community skills from --skills are unaffected.',
     'help.option.analyze.noStats': 'Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md',
     'help.option.analyze.selfCommit': 'Auto-commit AGENTS.md/CLAUDE.md changes after analyze (opt-in, off by default). Scoped to only those two files (never `git add -A`); no-ops if neither exists, neither changed, or the repo has no git identity configured.',
     '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.',

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

@@ -163,7 +163,7 @@ export declare const cliResources: {
         readonly 'help.option.analyze.embeddings': "Enable embedding generation for semantic search (off by default). Optional [limit] overrides the 50,000-node safety cap; pass 0 to disable the cap entirely.";
         readonly 'help.option.analyze.dropEmbeddings': "Drop existing embeddings on rebuild. By default, an `analyze` without `--embeddings` preserves any embeddings already present in the index.";
         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.skipAgentsMd': "Skip updating the gitnexus section in AGENTS.md and CLAUDE.md. Does not skip standard skills in .claude/skills or .agents/skills; use --skip-skills for those. Community skills from --skills are unaffected.";
         readonly 'help.option.analyze.noStats': "Omit volatile file/symbol counts from AGENTS.md and CLAUDE.md";
         readonly 'help.option.analyze.selfCommit': "Auto-commit AGENTS.md/CLAUDE.md changes after analyze (opt-in, off by default). Scoped to only those two files (never `git add -A`); no-ops if neither exists, neither changed, or the repo has no git identity configured.";
         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.";

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

@@ -162,7 +162,7 @@ export const zhCN = {
     'help.option.analyze.embeddings': '启用语义搜索的嵌入生成（默认关闭）。可选 [limit] 覆盖 50,000 节点安全上限；传 0 可完全禁用上限。',
     'help.option.analyze.dropEmbeddings': '重建时删除现有嵌入。默认情况下，未传 `--embeddings` 的 `analyze` 会保留索引中已有嵌入。',
     'help.option.analyze.skills': '根据检测到的社区生成仓库专属 skill 文件（同时设置 --index-only 时无效）。',
-    'help.option.analyze.skipAgentsMd': '跳过更新 AGENTS.md 和 CLAUDE.md 中的 gitnexus 区块',
+    'help.option.analyze.skipAgentsMd': '跳过更新 AGENTS.md 和 CLAUDE.md 中的 gitnexus 区块。不会跳过 .claude/skills 或 .agents/skills 下的标准 skill；如需跳过那些请使用 --skip-skills。--skills 生成的社区 skill 不受影响。',
     'help.option.analyze.noStats': '从 AGENTS.md 和 CLAUDE.md 中省略易变的文件/符号计数',
     'help.option.analyze.selfCommit': '在 analyze 后自动提交 AGENTS.md/CLAUDE.md 的变更（默认关闭，需显式开启）。仅限这两个文件（绝不使用 `git add -A`）；若两者均不存在、均未变更，或仓库未配置 git 身份，则不执行任何操作。',
     'help.option.analyze.skipSkills': '跳过直接安装在 .claude/skills/ 和 .agents/skills/ 下的标准 GitNexus skill 文件。不抑制 --skills 生成的社区 skill（位于 .claude/skills/gitnexus-area-*）。使用 --index-only 可跳过所有 AI 上下文文件注入。',

package/dist/cli/index.js

@@ -46,7 +46,7 @@ program
     'preserves any embeddings already present in the index.')
     .option('--skills', 'Generate repo-specific skill files from detected communities ' +
     '(no-op when --index-only is also set).')
-    .option('--skip-agents-md', 'Skip updating the gitnexus section in AGENTS.md and CLAUDE.md')
+    .option('--skip-agents-md', 'Skip updating the gitnexus section in AGENTS.md and CLAUDE.md. Does not skip standard skills in .claude/skills or .agents/skills; use --skip-skills for those. Community skills from --skills are unaffected.')
     .option('--pdg', 'Build the control-flow-graph / PDG substrate (BasicBlock nodes + CFG edges) ' +
     'for supported languages. Opt-in; off by default. (#2081 M1)')
     .option('--default-branch <branch>', 'Default branch used in the generated regression-compare example (base_ref). ' +

package/dist/cli/setup.js

@@ -947,15 +947,29 @@ async function installSkillsTo(targetDir) {
     for (const [skillName, source] of skillSources) {
         const skillDir = path.join(targetDir, skillName);
         try {
-            if (source.isDirectory) {
-                const dirSource = path.join(skillsRoot, skillName);
-                await copyDirRecursive(dirSource, skillDir);
+            const sourceSkillPath = source.isDirectory
+                ? path.join(skillsRoot, skillName, 'SKILL.md')
+                : path.join(skillsRoot, `${skillName}.md`);
+            const destinationSkillPath = path.join(skillDir, 'SKILL.md');
+            const [sourceSkillContent, destinationSkillContent] = await Promise.all([
+                fs.readFile(sourceSkillPath, 'utf-8'),
+                fs.readFile(destinationSkillPath, 'utf-8').catch((err) => {
+                    if (!isEnoent(err))
+                        throw err;
+                    return null;
+                }),
+            ]);
+            const preserved = destinationSkillContent !== null && destinationSkillContent !== sourceSkillContent;
+            if (preserved && !source.isDirectory) {
+                console.log(`[gitnexus] preserved customized skill ${destinationSkillPath}; ` +
+                    'delete the file and rerun setup to refresh it.');
             }
-            else {
-                const flatSource = path.join(skillsRoot, `${skillName}.md`);
-                const content = await fs.readFile(flatSource, 'utf-8');
+            else if (source.isDirectory) {
+                await copyDirRecursive(path.join(skillsRoot, skillName), skillDir);
+            }
+            else if (!preserved) {
                 await fs.mkdir(skillDir, { recursive: true });
-                await fs.writeFile(path.join(skillDir, 'SKILL.md'), content, 'utf-8');
+                await fs.writeFile(destinationSkillPath, sourceSkillContent, 'utf-8');
             }
             // A directory superseded by a shipped rename is warned about, never
             // deleted: the installer cannot prove it owns the contents (users
@@ -968,7 +982,8 @@ async function installSkillsTo(targetDir) {
                         `left ${legacyDir} in place — delete it manually if you have not customized it.`);
                 }
             }
-            installed.push(skillName);
+            if (!preserved)
+                installed.push(skillName);
         }
         catch {
             // Source skill not found — skip
@@ -987,10 +1002,22 @@ async function copyDirRecursive(src, dest) {
         const destPath = path.join(dest, entry.name);
         if (entry.isDirectory()) {
             await copyDirRecursive(srcPath, destPath);
+            continue;
         }
-        else {
-            await fs.copyFile(srcPath, destPath);
+        const [srcBuf, destBuf] = await Promise.all([
+            fs.readFile(srcPath),
+            fs.readFile(destPath).catch((err) => {
+                if (!isEnoent(err))
+                    throw err;
+                return null;
+            }),
+        ]);
+        if (destBuf !== null && !destBuf.equals(srcBuf)) {
+            console.log(`[gitnexus] preserved customized skill ${destPath}; ` +
+                'delete the file and rerun setup to refresh it.');
+            continue;
         }
+        await fs.writeFile(destPath, srcBuf);
     }
 }
 /**

package/dist/core/incremental/spring-config-drift.d.ts

@@ -0,0 +1,12 @@
+import type { KnowledgeGraph } from '../graph/types.js';
+export interface PersistedSpringConfigConsumerRow {
+    readonly id?: unknown;
+    readonly description?: unknown;
+}
+/**
+ * Find unchanged Spring consumer files whose unresolved markers changed.
+ *
+ * A removed config key also removes the old USES edge from the fresh graph, so
+ * ordinary new-graph boundary expansion cannot discover the consumer file.
+ */
+export declare function collectSpringConfigConsumerDriftFiles(graph: KnowledgeGraph, persistedRows: readonly PersistedSpringConfigConsumerRow[]): Set<string>;

package/dist/core/incremental/spring-config-drift.js

@@ -0,0 +1,46 @@
+import { SPRING_CONFIG_UNRESOLVED_PREFIX } from '../ingestion/frameworks/spring/config-bindings.js';
+const CONSUMER_LABELS = new Set(['Property', 'Class', 'Record']);
+function unresolvedKeys(description) {
+    if (typeof description !== 'string')
+        return [];
+    return description
+        .split(';')
+        .map((part) => part.trim())
+        .filter((part) => part.startsWith(SPRING_CONFIG_UNRESOLVED_PREFIX))
+        .map((part) => part.slice(SPRING_CONFIG_UNRESOLVED_PREFIX.length))
+        .sort();
+}
+/**
+ * Find unchanged Spring consumer files whose unresolved markers changed.
+ *
+ * A removed config key also removes the old USES edge from the fresh graph, so
+ * ordinary new-graph boundary expansion cannot discover the consumer file.
+ */
+export function collectSpringConfigConsumerDriftFiles(graph, persistedRows) {
+    const persistedById = new Map();
+    for (const row of persistedRows) {
+        if (typeof row.id !== 'string')
+            continue;
+        persistedById.set(row.id, unresolvedKeys(row.description));
+    }
+    const driftFiles = new Set();
+    graph.forEachNode((node) => {
+        if (!CONSUMER_LABELS.has(node.label))
+            return;
+        const filePath = node.properties.filePath;
+        if (typeof filePath !== 'string')
+            return;
+        const description = node.properties.description;
+        const persisted = persistedById.get(node.id);
+        if (persisted === undefined &&
+            (typeof description !== 'string' || !description.includes(SPRING_CONFIG_UNRESOLVED_PREFIX))) {
+            return;
+        }
+        const current = unresolvedKeys(description);
+        const prior = persisted ?? [];
+        if (current.length !== prior.length || current.some((key, index) => key !== prior[index])) {
+            driftFiles.add(filePath);
+        }
+    });
+    return driftFiles;
+}

package/dist/core/ingestion/frameworks/spring/config-bindings.d.ts

@@ -1,5 +1,6 @@
 import type { KnowledgeGraph } from '../../../graph/types.js';
 export declare const SPRING_CONFIG_DESCRIPTION = "Spring configuration property";
+export declare const SPRING_CONFIG_UNRESOLVED_PREFIX = "Spring config unresolved: ";
 export interface SpringValueConsumer {
     readonly kind: 'value';
     readonly fieldName: string;

package/dist/core/ingestion/frameworks/spring/config-bindings.js

@@ -1,5 +1,6 @@
 import { generateId } from '../../../../lib/utils.js';
 export const SPRING_CONFIG_DESCRIPTION = 'Spring configuration property';
+export const SPRING_CONFIG_UNRESOLVED_PREFIX = 'Spring config unresolved: ';
 function closestNode(candidates, filePath, name, line) {
     return candidates
         .filter((node) => node.properties.filePath === filePath && node.properties.name === name)
@@ -7,7 +8,7 @@ function closestNode(candidates, filePath, name, line) {
         Math.abs(Number(right.properties.startLine ?? 0) - line))[0];
 }
 function markUnresolved(node, key) {
-    const marker = `Spring config unresolved: ${key}`;
+    const marker = `${SPRING_CONFIG_UNRESOLVED_PREFIX}${key}`;
     const existing = typeof node.properties.description === 'string' ? node.properties.description : '';
     if (existing.includes(marker))
         return;

package/dist/core/ingestion/languages/java/analysis-features.d.ts

@@ -1,5 +1,5 @@
 import type { AnalysisFeatureDescriptor } from '../../../analysis-features.js';
-/** Durable completeness contract for Java Spring configuration bindings. */
+/** Durable completeness contract for Java and Kotlin Spring configuration bindings. */
 export declare const SPRING_CONFIG_BINDINGS_FEATURE: AnalysisFeatureDescriptor;
 /** Durable completeness contract for implicit Java record-component accessors. */
 export declare const JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/languages/java/analysis-features.js

@@ -2,14 +2,22 @@ function isSpringApplicationConfig(filePath) {
     const base = filePath.replaceAll('\\', '/').split('/').pop() ?? '';
     return /^application(?:-[^.]+)?\.(?:properties|ya?ml)$/i.test(base);
 }
-/** Durable completeness contract for Java Spring configuration bindings. */
+/** Durable completeness contract for Java and Kotlin Spring configuration bindings. */
 export const SPRING_CONFIG_BINDINGS_FEATURE = {
     id: 'spring.config-bindings',
-    version: 1,
-    // Java sources need consumer extraction even without config files (missing
-    // placeholders still get unresolved markers). Config-only repositories also
-    // need a one-time rebuild to backfill language-agnostic Property nodes.
-    appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java') || isSpringApplicationConfig(filePath)),
+    version: 2,
+    // Java and Kotlin sources need consumer extraction even without config files
+    // (missing placeholders still get unresolved markers). Config-only
+    // repositories also need a one-time rebuild to backfill language-agnostic
+    // Property nodes. Gradle Kotlin DSL is not a consumer source.
+    appliesTo: (filePaths) => filePaths.some((filePath) => {
+        const normalized = filePath.replaceAll('\\', '/').toLowerCase();
+        if (normalized.endsWith('.gradle.kts'))
+            return false;
+        return (normalized.endsWith('.java') ||
+            normalized.endsWith('.kt') ||
+            isSpringApplicationConfig(filePath));
+    }),
 };
 /** Durable completeness contract for implicit Java record-component accessors. */
 export const JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE = {

package/dist/core/ingestion/languages/kotlin/capture-side-channel.d.ts

@@ -44,6 +44,7 @@ import type { KotlinSpringAopFact } from './spring-aop.js';
 import type { KotlinSpringConditionalFact } from './spring-conditionals.js';
 import type { KotlinSpringDiClassFact } from './spring-di.js';
 import type { KotlinSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
+import type { KotlinSpringConfigConsumerFact } from './spring-config-bindings.js';
 /**
  * Plain JSON-serializable snapshot of the per-file Kotlin capture-time
  * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
@@ -68,6 +69,8 @@ export interface KotlinCaptureSideChannel {
     readonly springDynamicLookupFacts?: readonly SpringDynamicLookupFact[];
     /** Scheduled, event, messaging, and managed-job handler syntax captured per callable. */
     readonly springNonHttpHandlerFacts?: readonly KotlinSpringNonHttpHandlerFact[];
+    /** `@Value` / `@ConfigurationProperties` syntax captured per owner. */
+    readonly springConfigConsumerFacts?: readonly KotlinSpringConfigConsumerFact[];
 }
 export declare function clearKotlinClassAnnotationFacts(): void;
 export declare function setKotlinSpringAopFacts(filePath: string, facts: readonly KotlinSpringAopFact[]): void;
@@ -82,6 +85,8 @@ export declare function setKotlinSpringDynamicLookupFacts(filePath: string, fact
 export declare function getKotlinSpringDynamicLookupFacts(filePath: string): readonly SpringDynamicLookupFact[];
 export declare function setKotlinSpringNonHttpHandlerFacts(filePath: string, facts: readonly KotlinSpringNonHttpHandlerFact[]): void;
 export declare function getKotlinSpringNonHttpHandlerFacts(filePath: string): readonly KotlinSpringNonHttpHandlerFact[];
+export declare function setKotlinSpringConfigConsumerFacts(filePath: string, facts: readonly KotlinSpringConfigConsumerFact[]): void;
+export declare function getKotlinSpringConfigConsumerFacts(filePath: string): readonly KotlinSpringConfigConsumerFact[];
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
  * Returns `undefined` when this file recorded no side-channel state at all, so

package/dist/core/ingestion/languages/kotlin/capture-side-channel.js

@@ -46,6 +46,7 @@ const springConditionalFacts = new Map();
 const springDiFacts = new Map();
 const springDynamicLookupFacts = new Map();
 const springNonHttpHandlerFacts = new Map();
+const springConfigConsumerFacts = new Map();
 export function clearKotlinClassAnnotationFacts() {
     classAnnotations.clear();
     springAopFacts.clear();
@@ -53,6 +54,7 @@ export function clearKotlinClassAnnotationFacts() {
     springDiFacts.clear();
     springDynamicLookupFacts.clear();
     springNonHttpHandlerFacts.clear();
+    springConfigConsumerFacts.clear();
 }
 export function setKotlinSpringAopFacts(filePath, facts) {
     if (facts.length === 0)
@@ -105,6 +107,15 @@ export function setKotlinSpringNonHttpHandlerFacts(filePath, facts) {
 export function getKotlinSpringNonHttpHandlerFacts(filePath) {
     return springNonHttpHandlerFacts.get(filePath) ?? [];
 }
+export function setKotlinSpringConfigConsumerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConfigConsumerFacts.delete(filePath);
+    else
+        springConfigConsumerFacts.set(filePath, facts);
+}
+export function getKotlinSpringConfigConsumerFacts(filePath) {
+    return springConfigConsumerFacts.get(filePath) ?? [];
+}
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
  * Returns `undefined` when this file recorded no side-channel state at all, so
@@ -118,6 +129,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
     const diFacts = springDiFacts.get(filePath) ?? [];
     const dynamicLookupFacts = springDynamicLookupFacts.get(filePath) ?? [];
     const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
+    const configConsumerFacts = springConfigConsumerFacts.get(filePath) ?? [];
     const packageFact = getKotlinPackageFact(filePath);
     if (companionScopes.length === 0 &&
         annotationFacts.length === 0 &&
@@ -126,6 +138,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
         diFacts.length === 0 &&
         dynamicLookupFacts.length === 0 &&
         nonHttpHandlerFacts.length === 0 &&
+        configConsumerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
     }
@@ -139,6 +152,7 @@ export function collectKotlinCaptureSideChannel(filePath) {
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
         ...(dynamicLookupFacts.length > 0 ? { springDynamicLookupFacts: dynamicLookupFacts } : {}),
         ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
+        ...(configConsumerFacts.length > 0 ? { springConfigConsumerFacts: configConsumerFacts } : {}),
     };
 }
 /**
@@ -163,6 +177,7 @@ export function applyKotlinCaptureSideChannel(parsed) {
         setKotlinSpringDiFacts(parsed.filePath, []);
         setKotlinSpringDynamicLookupFacts(parsed.filePath, []);
         setKotlinSpringNonHttpHandlerFacts(parsed.filePath, []);
+        setKotlinSpringConfigConsumerFacts(parsed.filePath, []);
         setKotlinPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
     }
@@ -175,5 +190,6 @@ export function applyKotlinCaptureSideChannel(parsed) {
     setKotlinSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
     setKotlinSpringDynamicLookupFacts(parsed.filePath, Array.isArray(data.springDynamicLookupFacts) ? data.springDynamicLookupFacts : []);
     setKotlinSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
+    setKotlinSpringConfigConsumerFacts(parsed.filePath, Array.isArray(data.springConfigConsumerFacts) ? data.springConfigConsumerFacts : []);
     setKotlinPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }

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

@@ -10,11 +10,12 @@ import { normalizeKotlinType } from './interpret.js';
 import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
 import { getKotlinParser, getKotlinScopeQuery } from './query.js';
 import { markCompanionScope } from './companion-scopes.js';
-import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringDynamicLookupFacts, setKotlinSpringNonHttpHandlerFacts, } from './capture-side-channel.js';
+import { setKotlinClassAnnotationFacts, setKotlinSpringAopFacts, setKotlinSpringConditionalFacts, setKotlinSpringDiFacts, setKotlinSpringDynamicLookupFacts, setKotlinSpringNonHttpHandlerFacts, setKotlinSpringConfigConsumerFacts, } from './capture-side-channel.js';
 import { captureKotlinPackageFact } from './package-facts.js';
 import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 import { synthesizeLombokAccessorCaptures } from './lombok-synthesizer.js';
 import { captureKotlinSpringDiClassFact } from './spring-di.js';
+import { captureKotlinSpringConfigConsumerFacts } from './spring-config-bindings.js';
 import { captureKotlinSpringDynamicLookupFact } from './spring-dynamic-lookup.js';
 import { synthesizeReceiverChainCapture } from '../../utils/receiver-chain-captures.js';
 import { captureKotlinSpringAopFacts } from './spring-aop.js';
@@ -292,6 +293,7 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     setKotlinSpringDiFacts(filePath, springDiFacts);
     setKotlinSpringDynamicLookupFacts(filePath, springDynamicLookupFacts);
     setKotlinSpringNonHttpHandlerFacts(filePath, springNonHttpHandlerFacts);
+    setKotlinSpringConfigConsumerFacts(filePath, captureKotlinSpringConfigConsumerFacts(tree.rootNode, filePath));
     out.push(...synthesizeLombokAccessorCaptures(tree.rootNode));
     out.push(...synthesizeCallableFlowCaptures(tree.rootNode, KOTLIN_CALLABLE_CAPTURE_OPTIONS));
     return out;

package/dist/core/ingestion/languages/kotlin/scope-resolver.js

@@ -15,6 +15,7 @@ import { clearKotlinPackageFacts } from './package-facts.js';
 import { attachKotlinSpringDiMetadata } from './spring-di.js';
 import { attachKotlinSpringConditionalMetadata } from './spring-conditionals.js';
 import { attachKotlinSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
+import { attachKotlinSpringConfigBindings } from './spring-config-bindings.js';
 import { attachKotlinSpringDynamicLookup } from './spring-dynamic-lookup.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
@@ -123,6 +124,7 @@ export const kotlinScopeResolver = {
         attachKotlinSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachKotlinSpringDynamicLookup(graph, parsedFiles, nodeLookup, indexes);
+        attachKotlinSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes);
     },
 };
 /**

package/dist/core/ingestion/languages/kotlin/spring-config-bindings.d.ts

@@ -0,0 +1,18 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import { type ParsedFile, type ScopeId } from '../../../../_shared/index.js';
+import { type SpringConfigConsumer } from '../../frameworks/spring/config-bindings.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export interface KotlinSpringConfigConsumerFact {
+    readonly consumer: SpringConfigConsumer;
+    readonly annotationName: string;
+    readonly classScopeId: ScopeId;
+}
+/** Collect config facts from the Kotlin parser's existing AST (no reparse). */
+export declare function captureKotlinSpringConfigConsumerFacts(root: SyntaxNode, filePath: string): KotlinSpringConfigConsumerFact[];
+/** Parse Kotlin consumers for focused unit tests; production reuses the worker AST. */
+export declare function extractKotlinSpringConfigConsumers(source: string): SpringConfigConsumer[];
+export declare function extractKotlinSpringConfigConsumerFacts(source: string): KotlinSpringConfigConsumerFact[];
+/** Kotlin ScopeResolver post-resolution hook for Spring configuration consumers. */
+export declare function attachKotlinSpringConfigBindings(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], _nodeLookup: GraphNodeLookup, indexes: ScopeResolutionIndexes): void;

package/dist/core/ingestion/languages/kotlin/spring-config-bindings.js

@@ -0,0 +1,411 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { bindSpringConfigConsumers, } from '../../frameworks/spring/config-bindings.js';
+import { createSpringAnnotationNameResolver } from '../../frameworks/spring/bean-candidates.js';
+import { parseSpringAnnotationArguments, parseStaticStringLiteral, } from '../../frameworks/spring/annotation-arguments.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getKotlinParser } from './query.js';
+import { getKotlinSpringConfigConsumerFacts } from './capture-side-channel.js';
+import { isKotlinPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+const VALUE_ANNOTATION = 'org.springframework.beans.factory.annotation.Value';
+const CONFIGURATION_PROPERTIES_ANNOTATION = 'org.springframework.boot.context.properties.ConfigurationProperties';
+const VALUE_SIMPLE = 'Value';
+const CONFIGURATION_PROPERTIES_SIMPLE = 'ConfigurationProperties';
+const SKIP_USE_SITES = new Set(['get', 'property', 'file']);
+const BIND_USE_SITES = new Set(['field', 'set', 'param']);
+const OWNER_TYPES = new Set(['class_declaration', 'object_declaration', 'companion_object']);
+const INTERPOLATION_TYPES = new Set([
+    'interpolated_identifier',
+    'interpolated_expression',
+    'interpolation_expression_start',
+]);
+const STRING_LITERAL_TYPES = new Set(['string_literal', 'character_literal']);
+function firstDescendantOfType(node, type) {
+    const stack = [...node.namedChildren].reverse();
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (current.type === type)
+            return current;
+        for (let index = current.namedChildren.length - 1; index >= 0; index--) {
+            const child = current.namedChildren[index];
+            if (child !== undefined)
+                stack.push(child);
+        }
+    }
+    return undefined;
+}
+function ownerName(declaration) {
+    if (declaration.type === 'companion_object') {
+        const named = declaration.namedChildren.find((child) => child.type === 'type_identifier');
+        return named?.text.trim() || 'Companion';
+    }
+    return (declaration.namedChildren.find((child) => child.type === 'type_identifier')?.text.trim() ??
+        declaration.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim());
+}
+function enclosingOwner(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (OWNER_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return undefined;
+}
+function classScopeId(filePath, declaration) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@scope.class', declaration).range,
+        kind: 'Class',
+    });
+}
+function collectKotlinImports(root) {
+    const exact = new Map();
+    const wildcard = new Set();
+    const localTypes = new Map();
+    for (const header of root.descendantsOfType('import_header')) {
+        const text = header.text.replace(/^import\s+/, '').trim();
+        const aliasMatch = text.match(/^([\w.]+)\s+as\s+(\w+)\s*$/);
+        if (aliasMatch !== null) {
+            exact.set(aliasMatch[2], aliasMatch[1]);
+            continue;
+        }
+        if (text.endsWith('.*'))
+            wildcard.add(text.slice(0, -2));
+        else {
+            const simple = text.slice(text.lastIndexOf('.') + 1);
+            if (simple.length > 0)
+                exact.set(simple, text);
+        }
+    }
+    for (const type of ['class_declaration', 'object_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const name = ownerName(declaration);
+            if (name) {
+                const declarations = localTypes.get(name) ?? [];
+                declarations.push(declaration);
+                localTypes.set(name, declarations);
+            }
+        }
+    }
+    return { exact, wildcard, localTypes };
+}
+function annotationFromNode(annotation) {
+    const nameNode = firstDescendantOfType(annotation, 'user_type') ??
+        firstDescendantOfType(annotation, 'type_identifier') ??
+        firstDescendantOfType(annotation, 'simple_identifier');
+    if (nameNode === undefined)
+        return null;
+    const useSiteTarget = annotation.namedChildren
+        .find((child) => child.type === 'use_site_target')
+        ?.text.replace(/:\s*$/, '')
+        .trim();
+    return {
+        name: nameNode.text.trim(),
+        node: annotation,
+        ...(useSiteTarget === undefined || useSiteTarget.length === 0 ? {} : { useSiteTarget }),
+    };
+}
+function annotationsOn(node) {
+    const annotations = [];
+    for (const child of node.namedChildren) {
+        if (child.type === 'annotation') {
+            const fact = annotationFromNode(child);
+            if (fact !== null)
+                annotations.push(fact);
+            continue;
+        }
+        if (child.type !== 'modifiers' && child.type !== 'parameter_modifiers')
+            continue;
+        for (const nested of child.namedChildren) {
+            if (nested.type !== 'annotation')
+                continue;
+            const fact = annotationFromNode(nested);
+            if (fact !== null)
+                annotations.push(fact);
+        }
+    }
+    return annotations;
+}
+function simpleName(rawName) {
+    const parts = rawName.split('.');
+    return parts[parts.length - 1] ?? rawName;
+}
+function importedAs(imports, simple, fqn, wildcardPackage) {
+    if (imports.exact.get(simple) === fqn)
+        return true;
+    // An explicit import wins over a star import in Kotlin, so a conflicting
+    // binding for the same simple name rules the Spring annotation out even when
+    // its package is wildcard-imported.
+    return imports.exact.get(simple) === undefined && imports.wildcard.has(wildcardPackage);
+}
+function hasVisibleLocalType(imports, simple, annotation) {
+    for (const declaration of imports.localTypes.get(simple) ?? []) {
+        const declarationOwner = enclosingOwner(declaration);
+        if (declarationOwner === undefined)
+            return true;
+        let current = annotation;
+        while (current !== null) {
+            if (current.id === declarationOwner.id)
+                return true;
+            current = current.parent;
+        }
+    }
+    return false;
+}
+const SIMPLE_CONFIG_ANNOTATIONS = [
+    {
+        simple: VALUE_SIMPLE,
+        kind: 'value',
+        fqn: VALUE_ANNOTATION,
+        wildcardPackage: 'org.springframework.beans.factory.annotation',
+    },
+    {
+        simple: CONFIGURATION_PROPERTIES_SIMPLE,
+        kind: 'configuration-properties',
+        fqn: CONFIGURATION_PROPERTIES_ANNOTATION,
+        wildcardPackage: 'org.springframework.boot.context.properties',
+    },
+];
+function configAnnotationKind(annotation, imports) {
+    const rawName = annotation.name;
+    if (rawName === VALUE_ANNOTATION)
+        return 'value';
+    if (rawName === CONFIGURATION_PROPERTIES_ANNOTATION)
+        return 'configuration-properties';
+    const simple = simpleName(rawName);
+    const aliased = imports.exact.get(simple);
+    if (aliased === VALUE_ANNOTATION)
+        return 'value';
+    if (aliased === CONFIGURATION_PROPERTIES_ANNOTATION)
+        return 'configuration-properties';
+    for (const candidate of SIMPLE_CONFIG_ANNOTATIONS) {
+        if (simple !== candidate.simple)
+            continue;
+        if (hasVisibleLocalType(imports, simple, annotation.node) && !imports.exact.has(simple)) {
+            return null;
+        }
+        return importedAs(imports, simple, candidate.fqn, candidate.wildcardPackage)
+            ? candidate.kind
+            : null;
+    }
+    return null;
+}
+function hasInterpolation(annotation) {
+    const stack = [...annotation.namedChildren];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (INTERPOLATION_TYPES.has(current.type))
+            return true;
+        stack.push(...current.namedChildren);
+    }
+    return false;
+}
+function decodeKotlinStringLiteral(literal) {
+    const raw = literal.startsWith('"""') && literal.endsWith('"""');
+    const delimiterLength = raw ? 3 : 1;
+    if (literal.length < delimiterLength * 2)
+        return null;
+    const body = literal.slice(delimiterLength, -delimiterLength);
+    if (!raw && /(?<!\\)\$\{/.test(body))
+        return null;
+    if (raw)
+        return body;
+    return body
+        .replace(/\\u([0-9a-fA-F]{4})/g, (_match, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
+        .replace(/\\(["'\\$btnfr])/g, (_match, escaped) => {
+        const controls = {
+            b: '\b',
+            t: '\t',
+            n: '\n',
+            f: '\f',
+            r: '\r',
+            $: '$',
+        };
+        return controls[escaped] ?? escaped;
+    });
+}
+function kotlinStringLiterals(annotation) {
+    const literals = [];
+    const stack = [...annotation.namedChildren];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        if (STRING_LITERAL_TYPES.has(current.type)) {
+            const decoded = decodeKotlinStringLiteral(current.text);
+            if (decoded !== null)
+                literals.push(decoded);
+            continue;
+        }
+        stack.push(...current.namedChildren);
+    }
+    return literals;
+}
+function parseValuePlaceholderKeys(annotation) {
+    if (hasInterpolation(annotation))
+        return [];
+    const keys = new Set();
+    for (const literal of kotlinStringLiterals(annotation)) {
+        for (const match of literal.matchAll(/\$\{([^{}]+)\}/g)) {
+            const key = match[1].split(':', 1)[0].trim();
+            if (/^[A-Za-z0-9_.-]+$/.test(key))
+                keys.add(key);
+        }
+    }
+    return [...keys];
+}
+function parseConfigurationPropertiesPrefix(annotation) {
+    if (hasInterpolation(annotation))
+        return null;
+    const argumentsList = parseSpringAnnotationArguments(annotation.text);
+    if (argumentsList !== null) {
+        const named = argumentsList.filter((argument) => argument.name === 'prefix' || argument.name === 'value');
+        const positional = argumentsList.filter((argument) => argument.name === undefined);
+        const chosen = named.length === 1 ? named[0] : named.length === 0 ? positional[0] : undefined;
+        if (chosen !== undefined) {
+            const decoded = parseStaticStringLiteral(chosen.value);
+            if (decoded === null)
+                return null;
+            const prefix = decoded.replace(/^\.+|\.+$/g, '');
+            if (/^[A-Za-z0-9_.-]+$/.test(prefix))
+                return prefix;
+            return null;
+        }
+        if (argumentsList.length > 0)
+            return null;
+    }
+    const literals = kotlinStringLiterals(annotation);
+    if (literals.length !== 1)
+        return null;
+    const prefix = literals[0].trim().replace(/^\.+|\.+$/g, '');
+    return /^[A-Za-z0-9_.-]+$/.test(prefix) ? prefix : null;
+}
+function allowedUseSite(useSiteTarget) {
+    if (useSiteTarget === undefined)
+        return true;
+    if (SKIP_USE_SITES.has(useSiteTarget))
+        return false;
+    return BIND_USE_SITES.has(useSiteTarget);
+}
+function hasBindingPattern(parameter) {
+    return parameter.namedChildren.some((child) => child.type === 'binding_pattern_kind');
+}
+function propertyName(node) {
+    if (node.type === 'class_parameter') {
+        return node.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim();
+    }
+    const variable = node.namedChildren.find((child) => child.type === 'variable_declaration');
+    return variable?.namedChildren.find((child) => child.type === 'simple_identifier')?.text.trim();
+}
+function underFileAnnotation(node) {
+    let current = node;
+    while (current !== null) {
+        if (current.type === 'file_annotation')
+            return true;
+        current = current.parent;
+    }
+    return false;
+}
+function pushValueFacts(facts, member, filePath, imports) {
+    if (underFileAnnotation(member))
+        return;
+    const owner = enclosingOwner(member);
+    if (owner === undefined)
+        return;
+    const fieldName = propertyName(member);
+    if (fieldName === undefined)
+        return;
+    for (const annotation of annotationsOn(member)) {
+        if (!allowedUseSite(annotation.useSiteTarget))
+            continue;
+        if (configAnnotationKind(annotation, imports) !== 'value')
+            continue;
+        const keys = parseValuePlaceholderKeys(annotation.node);
+        if (keys.length === 0)
+            continue;
+        facts.push({
+            consumer: {
+                kind: 'value',
+                fieldName,
+                line: member.startPosition.row + 1,
+                keys,
+            },
+            annotationName: annotation.name,
+            classScopeId: classScopeId(filePath, owner),
+        });
+    }
+}
+/** Collect config facts from the Kotlin parser's existing AST (no reparse). */
+export function captureKotlinSpringConfigConsumerFacts(root, filePath) {
+    const imports = collectKotlinImports(root);
+    const facts = [];
+    for (const property of root.descendantsOfType('property_declaration')) {
+        pushValueFacts(facts, property, filePath, imports);
+    }
+    for (const parameter of root.descendantsOfType('class_parameter')) {
+        if (!hasBindingPattern(parameter))
+            continue;
+        pushValueFacts(facts, parameter, filePath, imports);
+    }
+    for (const type of ['class_declaration', 'object_declaration']) {
+        for (const declaration of root.descendantsOfType(type)) {
+            const className = ownerName(declaration);
+            if (className === undefined)
+                continue;
+            for (const annotation of annotationsOn(declaration)) {
+                if (configAnnotationKind(annotation, imports) !== 'configuration-properties') {
+                    continue;
+                }
+                const prefix = parseConfigurationPropertiesPrefix(annotation.node);
+                if (prefix === null)
+                    continue;
+                facts.push({
+                    consumer: {
+                        kind: 'configuration-properties',
+                        className,
+                        line: declaration.startPosition.row + 1,
+                        prefix,
+                    },
+                    annotationName: annotation.name,
+                    classScopeId: classScopeId(filePath, declaration),
+                });
+            }
+        }
+    }
+    return facts;
+}
+/** Parse Kotlin consumers for focused unit tests; production reuses the worker AST. */
+export function extractKotlinSpringConfigConsumers(source) {
+    const tree = parseSourceSafe(getKotlinParser(), source);
+    return captureKotlinSpringConfigConsumerFacts(tree.rootNode, '<memory>').map((fact) => fact.consumer);
+}
+export function extractKotlinSpringConfigConsumerFacts(source) {
+    const tree = parseSourceSafe(getKotlinParser(), source);
+    return captureKotlinSpringConfigConsumerFacts(tree.rootNode, '<memory>');
+}
+/** Kotlin ScopeResolver post-resolution hook for Spring configuration consumers. */
+export function attachKotlinSpringConfigBindings(graph, parsedFiles, _nodeLookup, indexes) {
+    const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+    const recognizedAnnotations = new Set([VALUE_ANNOTATION, CONFIGURATION_PROPERTIES_ANNOTATION]);
+    const batches = [];
+    for (const parsed of parsedFiles) {
+        const consumers = [];
+        for (const fact of getKotlinSpringConfigConsumerFacts(parsed.filePath)) {
+            const classScope = indexes.scopeTree.getScope(fact.classScopeId);
+            if (classScope === undefined || classScope.kind !== 'Class')
+                continue;
+            const expectedAnnotation = fact.consumer.kind === 'value' ? VALUE_ANNOTATION : CONFIGURATION_PROPERTIES_ANNOTATION;
+            const enclosingScope = fact.consumer.kind === 'value' ? classScope.id : classScope.parent;
+            const resolved = resolveAnnotation(fact.annotationName, parsed, enclosingScope, recognizedAnnotations, isKotlinPackageSiblingVisibilityIncomplete(parsed.filePath));
+            if (resolved === expectedAnnotation)
+                consumers.push(fact.consumer);
+        }
+        if (consumers.length > 0)
+            batches.push({ filePath: parsed.filePath, consumers });
+    }
+    bindSpringConfigConsumers(graph, batches);
+}

package/dist/core/run-analyze.js

@@ -41,6 +41,7 @@ import { taintModelVersion } from './ingestion/taint/typescript-model.js';
 import { parseTruthyEnv, parsePositiveIntEnv } from './ingestion/utils/env.js';
 import { computeFileHashes, diffFileHashes } from '../storage/file-hash.js';
 import { extractChangedSubgraph, computeEffectiveWriteSet, } from './incremental/subgraph-extract.js';
+import { collectSpringConfigConsumerDriftFiles, } from './incremental/spring-config-drift.js';
 import { shadowCandidatesFor } from './incremental/shadow-candidates.js';
 import { shouldEscalateIncrementalWrite } from './incremental/escalation-gate.js';
 import { ftsTablesAmong, incrementalFtsTablesFromGraph, nodeTablesForIncrementalDelete, shouldPreservePersistedDerivedGraph, } from './incremental/derived-writeback.js';
@@ -55,6 +56,8 @@ import { sanitizeDetectedBranch } from '../cli/analyze-config.js';
 import { EMBEDDING_TABLE_NAME, EMBEDDING_DIMS, STALE_HASH_SENTINEL, SCHEMA_FINGERPRINT, schemaFingerprintMismatch, isSchemaFingerprintShaped, embeddingDimsMismatch, } from './lbug/schema.js';
 import { isSpringBeanCandidateSourceFile } from './ingestion/frameworks/spring/bean-catalog.js';
 import { isSpringBeanFactoryDeclaration } from './ingestion/frameworks/spring/bean-factories.js';
+import { SPRING_CONFIG_UNRESOLVED_PREFIX } from './ingestion/frameworks/spring/config-bindings.js';
+import { classifySpringConfigFile } from './ingestion/pipeline-phases/spring-config.js';
 import { SPRING_AOP_FEATURE, SPRING_BEAN_INVENTORY_FEATURE, SPRING_CONDITIONALS_FEATURE, SPRING_NON_HTTP_HANDLERS_FEATURE, } from './ingestion/frameworks/spring/analysis-features.js';
 import { JAVA_ENUM_INTERFACE_HERITAGE_FEATURE, JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE, SPRING_CONFIG_BINDINGS_FEATURE, } from './ingestion/languages/java/analysis-features.js';
 import { CLASS_FRAMEWORK_ANNOTATIONS_FEATURE, findAnalysisFeatureMismatches, resolveAnalysisFeatureVersions, } from './analysis-features.js';
@@ -1812,6 +1815,29 @@ async function runFullAnalysisInner(repoPath, options, callbacks, writeTarget, r
             //    and extractChangedSubgraph — asymmetry between the two would
             //    leave stale rows or PK-conflict at COPY time.
             const effectiveWriteSet = computeEffectiveWriteSet(pipelineResult.graph, writableFiles);
+            const springConfigChanged = hashDiff.toWrite.some((filePath) => classifySpringConfigFile(filePath) !== null) ||
+                hashDiff.deleted.some((filePath) => classifySpringConfigFile(filePath) !== null);
+            if (springConfigChanged) {
+                const unresolvedPrefix = escapeCypherString(SPRING_CONFIG_UNRESOLVED_PREFIX);
+                const persistedSpringConfigConsumers = (await executeQuery('MATCH (n:Property) ' +
+                    `WHERE n.description CONTAINS '${unresolvedPrefix}' ` +
+                    'RETURN n.id AS id, n.description AS description ' +
+                    'UNION ALL ' +
+                    'MATCH (n:Class) ' +
+                    `WHERE n.description CONTAINS '${unresolvedPrefix}' ` +
+                    'RETURN n.id AS id, n.description AS description ' +
+                    'UNION ALL ' +
+                    'MATCH (n:Record) ' +
+                    `WHERE n.description CONTAINS '${unresolvedPrefix}' ` +
+                    'RETURN n.id AS id, n.description AS description'));
+                const springConfigConsumerDriftFiles = collectSpringConfigConsumerDriftFiles(pipelineResult.graph, persistedSpringConfigConsumers);
+                for (const filePath of springConfigConsumerDriftFiles)
+                    effectiveWriteSet.add(filePath);
+                if (springConfigConsumerDriftFiles.size > 0) {
+                    log(`Incremental: +${springConfigConsumerDriftFiles.size} file(s) added for ` +
+                        'Spring config consumer property drift');
+                }
+            }
             // `frameworkAnnotations` is derived from cross-file JVM visibility, so
             // an unchanged Class row can change when a same-package declaration is
             // added or removed without producing an IMPORTS edge. Compare the fresh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.26",
+  "version": "1.6.11-rc.28",
   "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",