Multi-Concern Detection in Tangled Commits

• The paper introduces multi-concern detection in tangled commits, detailing pairwise clustering and multi-label classification to demarcate distinct semantic intents.
• It leverages curated datasets, synthetic tangles, and production repositories with code diffs and commit messages to establish robust ground-truth partitions.
• LLM-driven and multi-agent frameworks integrate explicit dependency analysis with semantic reasoning for iterative refinement and improved code intelligence.

Multi-concern detection in tangled commits refers to the automated identification and disentanglement of unrelated development concerns—such as bug fixes, refactorings, feature additions, documentation updates, and test modifications—that are erroneously bundled within a single version control commit. This problem is central to code intelligence research, as tangled commits obscure change provenance, complicate review, hinder accurate software maintenance, and degrade the quality of downstream mining tasks such as bug prediction or change impact analysis (Opu et al., 13 May 2025, Koh et al., 29 Jan 2026, Zhu et al., 3 Jan 2026, Hou et al., 22 Jul 2025, Dias et al., 2015).

1. Problem Formulation and Theoretical Foundations

In state-of-the-art literature, the multi-concern detection task is consistently framed as a clustering or multi-label classification problem at varying code granularities. A commit $C$ comprises a set of changed artifacts—ranging from fine-grained “change events” (methods/statements) to minimal change subgraphs (MCSs) in the abstract syntax tree (AST) (Zhu et al., 3 Jan 2026, Dias et al., 2015, Opu et al., 13 May 2025). The mathematical goal is to partition $C = \{\Delta_1, \Delta_2, ..., \Delta_n\}$ into $k$ blocks $G_1, ..., G_k$ such that each $G_i$ contains code changes linked by a single semantic intent $\theta_i$, i.e., $\bigcup_{i=1}^k G_i = C$, $G_i \cap G_j = \varnothing$ for $i \ne j$ (Hou et al., 22 Jul 2025, Zhu et al., 3 Jan 2026).

Recent work operationalizes multi-concern detection either as:

• Pairwise clustering: Learning a classifier $f(\Delta_i, \Delta_j) \to \{0,1\}$ to estimate whether two changes belong to the same concern, followed by agglomerative clustering (Dias et al., 2015).
• Multi-label classification: Assigning a vector $y \in \{0,1\}^K$ to a commit, where $y_k = 1$ iff concern $k$ (from a taxonomy such as Conventional Commits) is present (Koh et al., 29 Jan 2026).
• Intent-coherence maximization: Partitioning MCSs so as to maximize within-group semantic intent alignment as inferred by an LLM (Zhu et al., 3 Jan 2026).

The demarcation of atomic (single-intent) vs. tangled (multi-intent) commits is thus both structural (syntactic dispersal of edits) and semantic (divergence of developer goals).

2. Datasets, Taxonomies, and Input Modalities

Empirical research into multi-concern detection relies on curated or synthesized datasets that offer reliable intention labels:

• Fine-grained logs: Developer-instrumented logging tools (e.g., Epicea) capturing exact change events and manual cluster assignments, guaranteeing ground-truth partitions of concerns (Dias et al., 2015).
• Synthetic tangles: Constructed datasets by merging multiple real-world atomic commits of known types to produce controlled, multi-concern “tangled” samples (Koh et al., 29 Jan 2026, Zhu et al., 3 Jan 2026, Hou et al., 22 Jul 2025).
• Production repositories: Large-scale, method-level histories from real projects (e.g., 774,051 methods across 49 Java repositories) labeled via manual or semi-automated annotation (Opu et al., 13 May 2025).

Taxonomies of concern types are commonly derived from the Conventional Commits Specification, with filtered categories (e.g., {feat, fix, refactor, docs, test, build, ci}) to ensure label distinctness (Koh et al., 29 Jan 2026). Input modalities encompass:

• Code diffs: Method-level or AST-level diff hunks with both added and removed lines (Opu et al., 13 May 2025, Koh et al., 29 Jan 2026).
• Commit messages: Raw or minimally processed logs that often contain critical semantic cues about concern intent (Opu et al., 13 May 2025, Koh et al., 29 Jan 2026).

3. Automated Detection Methodologies

Multi-concern detection approaches fall into several broad families, each reflecting different theoretical and practical priorities:

3.1 Feature- and Rule-Based Learning

Early approaches (e.g., EpiceaUntangler (Dias et al., 2015)) extract features (“voters”) from code history, structure, and edit metadata, learning pairwise classifiers (random forest, logistic regression) over features such as temporal proximity, same-class, or code similarity. Clusters are built by agglomerating pairs whose predicted likelihood of same concern exceeds a learned threshold.

3.2 Graph-Based and Hybrid Clustering

Graph clustering methods employ Program Dependency Graphs (PDGs) or AST-based representations, clustering code entities by explicit structural (data/control flow) or implicit relationships (token/AST similarity) (Hou et al., 22 Jul 2025). Hybrid frameworks, such as ColaUntangle, instantiate explicit-dependency agents for symbolic context and implicit-dependency agents using LLMs for semantic similarity, synthesizing beliefs through reviewer agents in an iterative consultation loop (Hou et al., 22 Jul 2025).

3.3 LLM- and SLM-Based Pipelines

LLM-driven detection systems formulate classification as either binary/multi-class tasks (is a code change part of specific concern type?) or multi-label assignments at granularities such as method or diff hunk (Opu et al., 13 May 2025, Koh et al., 29 Jan 2026). Techniques include:

• Prompt engineering: Zero-shot, few-shot, chain-of-thought, and hybrid prompting strategies using LLMs (GPT-4o, Gemini-2.0-Flash) (Opu et al., 13 May 2025).
• Embedding-based learning: Extracting fixed-size embeddings from concatenated commit message and code diff, then training discriminative classifiers (e.g., multilayer perceptrons) (Opu et al., 13 May 2025).
• Fine-tuned SLMs: Open models (Qwen3-14B) adapted via LoRA with multi-label binary cross-entropy loss; input encompasses message and diff, with header-preserving truncation applied under token budget constraints (Koh et al., 29 Jan 2026).

3.4 Multi-Agent Collaborative Frameworks

State-of-the-art frameworks introduce multi-agent collaboration:

• Atomizer: Employs Purifier/Profiler/Refinement stages—distilling minimal context, inferring intent profiles via IO-CoT (explicit What/How/Why), and iteratively grouping changes through Grouper–Reviewer loops (Zhu et al., 3 Jan 2026).
• Consultation protocols in ColaUntangle allow explicit and implicit agents to reason over the same commit, with a reviewer agent adjudicating, iteratively refining clusters based on both symbolic dependency and LLM-based semantic evidence (Hou et al., 22 Jul 2025).

4. Evaluation Protocols and Empirical Results

Evaluation leverages metrics aligned to both clustering quality and classification accuracy, contingent on the abstraction level:

Metric	Formula / Description	Representative Source
Precision, Recall	Standard definitions for per-class/label predictions	(Opu et al., 13 May 2025, Dias et al., 2015)
F₁ Score	$F_1 = \frac{2PR}{P+R}$	(Opu et al., 13 May 2025, Dias et al., 2015)
Hamming Loss	$(1/K) \sum_{i=1}^K 1[y_i \neq \hat{y}_i]$	(Koh et al., 29 Jan 2026)
Cluster Accuracy	Fraction changed statements correctly grouped	(Hou et al., 22 Jul 2025, Zhu et al., 3 Jan 2026)
Matthews CC	$\mathrm{MCC} = \frac{TP \,TN - FP\,FN}{...}$	(Opu et al., 13 May 2025)
Jaccard SuccessRate	Proportion of changes correctly clustered (Jaccard match)	(Dias et al., 2015)

Empirical results show:

• Feature-based (RF) clustering achieves median success rates of 91% under developer-supervised evaluation (Dias et al., 2015).
• LLMs (GPT-4o, Gemini): Best F₁ of 0.883 (few-shot+CoT, commit message + diff) at the method level; MLP on LLM embeddings achieves F₁=0.906, MCC=0.807 (Opu et al., 13 May 2025).
• SLMs (Qwen3-FT, 14B): For commits with up to three concerns, Hamming Loss ≈ 0.18, competitive with GPT-4.1; inclusion of commit message text improves accuracy by up to 44% (Koh et al., 29 Jan 2026).
• Multi-agent frameworks (Atomizer, ColaUntangle): Atomizer achieves 57.0% average changed-node accuracy (C#), outperforms graph baselines by >6% overall and >16% for complex commits (Zhu et al., 3 Jan 2026); ColaUntangle’s cluster accuracy improves by 44% (C#) and 100% (Java) over best prior (HD-GNN) (Hou et al., 22 Jul 2025).

5. Critical Advances: Semantic Intent and Collaborative Refinement

Modern frameworks overcome historic limitations of single-pass, structure-centric methods by:

• Explicit modeling of developer intent via LLM chain-of-thought, enforcing What–How–Why articulation to capture the semantic rationale for changes (Zhu et al., 3 Jan 2026).
• Iterative grouping and outlier handling, inspired by human review—multiple agents propose groupings, reviewers detect incoherence, and the process continues until global intent-consistency is achieved (Zhu et al., 3 Jan 2026, Hou et al., 22 Jul 2025).
• Separation of explicit (symbolic/control/data flow) and implicit (semantic, text/clone) dependency reasoning, increasing interpretability and accuracy via agent specialization (Hou et al., 22 Jul 2025).
• Empirical demonstration that structural-only techniques fail on semantically entangled commits, whereas LLM-driven agents prevent accidentally merging disparate concerns (Zhu et al., 3 Jan 2026, Hou et al., 22 Jul 2025).

6. Practical Applications, Limitations, and Future Directions

Multi-concern untangling enhances:

• Method-level bug datasets, essential for high-precision bug prediction (Opu et al., 13 May 2025).
• Developer workflows—IDE plugins, Git pre-commit hooks, CI pipelines triggering alerts or automatic untangling (Koh et al., 29 Jan 2026, Opu et al., 13 May 2025).
• Large-scale software repository mining, by mitigating historical noise from tangled commits (Dias et al., 2015).

There remain open challenges:

• Generalization: Most current work is validated only on Java, C#, or dynamically typed environments; adaptation to further languages and real (non-synthetic) tangled commits is unproven (Opu et al., 13 May 2025, Dias et al., 2015, Hou et al., 22 Jul 2025).
• Performance and efficiency: LLM-based methods can be costly (125 s/commit, $2.92/100 examples for DeepSeek-V3 (Hou et al., 22 Jul 2025)), suggesting the need for hybrid pipelines and automatic complexity detection.
• Ground truth and subjectivity: Manual labeling and synthetic tangling may introduce biases not fully controlled for (construct and external validity) (Opu et al., 13 May 2025, Hou et al., 22 Jul 2025).

Future research directions include expanding concern taxonomies (beyond bug/feature/refactor), automatic route-to-hybrid pipelines (SLM for simple, LLM for complex commits), integration of real developer feedback for online adaptation, and deployment of untangling agents in real-world collaborative software engineering platforms (Opu et al., 13 May 2025, Zhu et al., 3 Jan 2026, Hou et al., 22 Jul 2025).

7. Summary Table of Prominent Approaches and Empirical Findings

Paper	Approach Type	Dataset / Granularity	Top-line Performance	Notable Insights
(Dias et al., 2015) Dias et al.	RF pairwise + clustering (Epicea)	Pharo, fine-grained	Median 91% clustering success	3 features dominate, minimal data
(Opu et al., 13 May 2025)	LLM (GPT/Gemini) prompt/embedding	Java, method-level	F₁=0.883 (hybrid), MLP F₁=0.906	Commit message crucial, MCC=0.807
(Koh et al., 29 Jan 2026) Koh et al.	SLM multi-label; token-budget	Synthetic (CCS), diff	HL=0.18 (up to 3 concerns, 14B SLM)	Message inclusion: –44% HL
(Hou et al., 22 Jul 2025)	Multi-agent explicit/implicit LLM	C#/Java, diff/ΔPDG	44–100% rel. accuracy gain (cluster)	Consultation essential
(Zhu et al., 3 Jan 2026)	Multi-agent IO-CoT (Atomizer)	C#/Java (AST/MCS)	+6 to +16% acc vs. graph-clustering	Reviewer loop, IO-CoT superior

This synthesis demonstrates a rapid evolution from feature-based clustering to intent-aware, LLM-driven, and multi-agent collaborative detection of multi-concern patterns in tangled commits, establishing new empirical best practices, theoretical clarity, and actionable paths for future research.