Summary / 05. Issue and fault localization / Document
Paper 2026-09-05
Shared copy: the operator's name and machine names are replaced by roles. Nothing else is changed.
Rendering…
# From Symptom to Site: Hierarchical, Evidence-Fused, Deterministic-First Fault Localization for a Weak-Model Coding Harness *Component 05 of 27 — Coding-Harness Program. This document specifies the issue/fault-localization stage: the conversion of a natural-language symptom ("feature X is broken") into a ranked, causally-explained set of candidate edit sites — files, then entities, then statements — before any patch is attempted. It sits between component 03 (reconnaissance: what is this repository) and component 04 (retrieval: what context is relevant), and answers the question neither of them does: of the relevant code, where precisely is the fault. It is written to drive a reversible build; the executable specification follows in a companion document.* --- ## Abstract Fault localization — deciding *where* to edit before deciding *what* to edit — is the stage that bounds everything downstream: a repair engine cannot fix a fault whose site it never places in context. This paper argues that localization should be hierarchical (files → entities → statements), evidence-fused (semantic, structural, dynamic/SBFL, stack-trace, and git-history signals, each computed independently), and deterministic-first: a fused deterministic pre-filter shrinks the repository to a small ranked candidate set, and a language model is invoked only to adjudicate ambiguous causal hypotheses, as a listwise re-ranker that emits identifiers, never as an explorer. The deterministic ranker is the workhorse and can beat the language model outright; in the common agreement case the learned column is empty. The paper reviews seven lines of prior work, derives six design principles, specifies an architecture in which every node is labeled deterministic or learned, and prescribes a measurement regime that reports localization quality *honestly* — against ground-truth-from-patch metrics and contamination-aware controls rather than leaderboard vibes. For a weak model on CPU, the entire localization pipeline is deterministic software; the model's single possible role is disagreement-case adjudication over an already-small shortlist. ## 1. Introduction The coding-harness program decomposes software engineering into a sequence of questions, and components 01 through 04 answered the opening four: how to *interact* with the code (01), how to *choose* an action (02), what the repository *is* (03), and what context is *relevant* (04). This paper answers the question that turns a retrieved slice into a repaired repository: *of the relevant code, where is the fault?* Component 05, issue/fault localization, consumes a natural-language symptom and produces a ranked, causally-explained set of candidate edit sites before any patch is generated. Localization is a *distinct phase*, not a sub-routine of repair, because its output is a different kind of object. Repair produces a patch — an executable change to be tested. Localization produces a *fault hypothesis with a verifiable target*: the claim "the symptom is caused by the code at entity *e*, statement *s*, under condition *c*" is checkable against a ground truth that exists independently of the hypothesis, namely the patch that the benchmark's maintainers actually merged. That verifiability is what makes localization measurable in isolation (Section 6), and measurability is what makes it improvable. A phase that cannot be scored separately from its consumer cannot be diagnosed separately, and localization is routinely lost inside end-to-end resolve-rate numbers that conflate it with planning, editing, and validation quality. The central fact of the problem is *search-space reduction*. Real repositories span roughly 10⁶ to 10⁸ tokens of source; a patch touches a handful of statements. The localization stage's entire job is to turn the first number into the second — to shrink a multi-million-line repository into a candidate set small enough that a weak model, or a deterministic rule, can finish the job. Every design decision in this paper is downstream of that reduction. Coarse granularity (files and entities) is cheap to rank and carries structural information — a function's signature and callers say more about whether it *could* be the fault than its body says about whether it *is*. Fine granularity (statements) is expensive and should be spent only on the survivors. A second, subtler fact is that *symptom is not cause*. The three places a naive pipeline would look — the failing assertion, the traceback's top frame, and the line that is actually wrong — are three *different* places. The failing assertion is where the system noticed something wrong; the top traceback frame is where execution happened to be when it surfaced; the buggy line is where the wrong state was first produced — possibly a different function or module, reached through calls the traceback does not record. A localizer that equates symptom with cause will confidently return the wrong site. The evidence fusion of Section 4 exists to break that equation, letting independent signals veto or confirm the semantic reading of the symptom. Localization quality *bounds* resolve rate. This is not an assertion; it is the central empirical finding the related-work review returns to repeatedly. OrcaLoca measures the causal chain directly: feeding its localization into a repair stage raises resolved rate by 6.33 percentage points and function-match by 6.67 points — better localization *causes* better repair [5]. Agentless reports the mirror image: its residual failures are predominantly localization misses, not repair failures [2]. If the site never reaches the model's context, no model, however capable, can fix it. Localization is therefore the *ceiling* on the whole program, and the ceiling is set before a single token of patch generation is spent. The relation to neighboring components must be drawn precisely, because the three are contiguous and easily conflated. Reconnaissance (03) is *orientation*: one amortized pass that builds the map. Retrieval (04) is *selection*: the continuous, per-decision pulling of the minimal relevant context. Localization (05) is *discrimination*: the once-per-issue ranking that separates the fault site from everything else relevant. A harness can have a perfect map and a perfect retriever and still fix nothing if it cannot rank the correct file above the ninety plausible-looking ones the retriever dutifully returned. Localization is the funnel's final, narrowest constriction. The thesis follows from these observations. **Issue localization should be hierarchical (files → entities → statements), evidence-fused (semantic + structural + dynamic/SBFL + stack-trace + git-history — several independent signals), and deterministic-first: a fused deterministic pre-filter shrinks the repository to a small ranked candidate set, and the language model adjudicates ambiguous causal hypotheses only after deterministic evidence has reduced the space — as a listwise re-ranker that emits identifiers, never as an explorer.** The deterministic ranker is the workhorse, and the review shows it can beat the language model on its own; localization must therefore be measured *honestly*, against memorization contamination, not leaderboard vibes. The paper proceeds as follows. Section 2 reviews seven lines of prior work, each with its claims, numbers, and weak-model/CPU implication. Section 3 derives six design principles. Section 4 specifies the architecture, labeling every node deterministic (D) or learned (L). Section 5 states the recursive self-improvement protocol. Section 6 gives the measurement plan. Section 7 concludes. ## 2. Related Work The literature divides into seven lines, each answering one question the localization stage must resolve: what is the phase structure (hierarchical anchor), what is the computation (ranking vs. search), how to schedule exploration, how to build the graph lazily, how to use dynamic evidence, how to use historical evidence, and how to measure without self-deception. ### 2.1 The hierarchical anchor: Agentless **Agentless** [2] is the anchor for this component because it makes localization an *explicit, named phase* rather than an emergent behavior of a wandering agent. Its pipeline is deterministic localize → repair → validate, and its localization step is a hierarchical funnel: candidate *files*, then *elements* (classes and functions) within those files, then *edit locations*. The headline result is 32% on SWE-bench-Lite (96/300) and 38.8% on SWE-bench-Verified, at $0.70 per issue and 78K tokens — achieved by *not* letting the model roam. The decisive diagnostic is the failure analysis: most residual failures are localization misses, not repair misses. The lesson is architectural: localization is where the error budget is spent, and Agentless shows the phase can be made hierarchical and mostly deterministic while remaining competitive with agentic systems that cost more. ### 2.2 Localization as ranking, not search: SweRank **SweRank** [4] reframes localization from *search* — an agent exploring the repository until it stumbles on the answer — to *ranking*: score every candidate location and return the top. Its motivation is a measurement of the query side of the problem: issue descriptions are verbose and failure-descriptive, around 460 tokens on average versus roughly 12 for the CodeSearchNet queries that functionality-matching retrievers were built for. A retriever tuned for short "find this function" queries misfires on "the application crashes when I do X and here is the traceback." SweRank answers with a two-stage retrieve-and-rerank design: a bi-encoder (SweRankEmbed) trained on SweLoc, a dataset of 67,341 issue-to-code pairs, followed by a listwise language-model re-ranker (SweRankLLM). The numbers are the point. On function-level Acc@10: BM25 reaches 36.86%; SweRankEmbed-Small (137M parameters) reaches 74.45%; the 7B large variant reaches 82.12%; the re-ranker lifts the range to 86.13–88.69%. Two findings carry the weak-model/CPU lesson. First, the 137M retriever *beats* the 7B embedders, and beats LocAgent and Claude-3.5 as well — a small deterministic-compatible model outperforming much larger systems on the discrimination task. Second, the economics are stark: approximately $0.011 per instance against about $0.66, roughly a 6× performance-per-dollar advantage. SweRank also contributes the brittleness critique of agentic localization: a multi-step search is a chain, and one bad step derails the whole chain, whereas a ranker degrades gracefully. Its training trick is worth recording because it determines what the learned component must be capable of: the listwise re-ranker needs to predict only the single positive identifier, which is why a listwise formulation can be small and cheap. ### 2.3 Prioritized exploration: OrcaLoca **OrcaLoca** [5] treats localization as *its own optimization problem* and solves it with scheduling rather than search. Its contribution is three mechanisms: priority-based scheduling (an ASQ heap with a repetition counter, so the agent explores high-value locations first and does not re-visit dead ends), action decomposition with relevance scoring (each candidate action is scored before execution), and distance-aware context pruning (top-k = 12, applied at every step, so context never grows past what the current frontier needs). It reaches 65.33% function-match and 83.33% file-match. The most important result is causal, not descriptive: feeding OrcaLoca's localization into a repair stage raises the *resolved rate* by 6.33 percentage points and function-match by 6.67 points — the better-localization → better-repair → higher-resolve chain is *measured*, not assumed. Each of the three mechanisms contributes roughly 3–5 percentage points, and none dominates, which is a warning against single-mechanism designs. For this paper the crucial transferable observation is architectural: OrcaLoca's scheduler is, in effect, a *deterministic priority-queue beam search over the call graph*, with the language model demoted to scoring candidates at the frontier. The "de-LLM" — recognizing which parts of an agent are really just deterministic search wearing an agent costume — is exactly the substitution this harness wants to make wholesale. ### 2.4 Lazy graph construction: CoSIL **CoSIL** [6] addresses the cost of the structural signal: a full repository index is expensive to build and often unnecessary. It constructs the call/module graph *incrementally, on demand*, with no upfront index — it starts from the module import graph, expands into the function call graph, and bounds the expansion to a BFS of at most 10 iterations. A boolean *pruner* gates every expansion: given a snippet, "is this related to the issue?" — a reject answer prunes the entire path, so the graph is only built where the issue plausibly lives. A reflective-alignment step re-ranks at the end of each stage. It reports function Top-1 of 43.3% on SWE-bench-Lite and 44.6% on SWE-bench-Verified, at about $0.02 per instance using DeepSeek-v3 — described as the cheapest agentic localizer. The core ablation is the caution: removing the iterative search costs approximately 20 points. The lesson is double-edged and important for a deterministic-first design: lazy, relevance-gated graph expansion is the right structure (it is cheap and can be made fully deterministic), but the *gate itself* — the "is this snippet related" judgment — is the one place CoSIL still spends the model, and it is the one place this harness must find a deterministic substitute or a cheap learned one. ### 2.5 Dynamic evidence: LLM4FL **LLM4FL** [7] supplies the dynamic-evidence discipline and the single most important empirical claim in this component's favor. Its starting problem is that *coverage evidence exceeds context*: a failing test exercises many methods, and feeding all of them to a language model overflows its window. Its solution is order-aware segmentation: sort the covered methods by Ochiai (spectrum-based) suspiciousness, bucket them into token-sized windows, prune stack traces of external-library frames, and truncate test bodies at the first failing assertion. It reaches Top-1 on 326 of 675 faults (48.3%), against 275 for the AutoFL baseline (+18.55%). The ablations invert the usual priority: *division* (the segmentation) is the largest factor at −19 to −23 percentage points when removed, code-navigation costs −11 to −17, and reflexion (self-critique) only −6 to −11 — the deterministic rank-and-segment machinery matters more than the self-reflection. The ordering experiment is the decisive result for this paper: sorting by Ochiai gains 8 points, sorting by DepGraph gains 22, and — most strikingly — a *purely deterministic* DepGraph ordering (call graph plus git history) *beats the language model* outright, 359 versus 326. Cost is about $0.050 per fault. This is direct, published evidence that a deterministic ranker can outperform a learned one on fault localization when the ranking signal is structural and historical rather than semantic. ### 2.6 Historical evidence: Repository Memory **Repository Memory** [8] supplies the historical signal: commit history as localization memory, on the principle that bugs cluster where they have clustered before. It builds episodic memory (commits linked to issues, retrieved via SearchCommit) and semantic memory (top-K code churn hotspots, K = 200, summarized once by a language model), reaching Acc@5 of 76.5%, a 4.9-point gain over LocAgent. Two findings carry the CPU lesson: a BM25 retriever *with an LLM-based tokenizer* beats a dense retriever (GritLM-7B) — no embeddings, no GPU — and the paper's anti-leakage protocol (pre-date commits only, overlapping-text issues filtered) is the measurement discipline this harness adopts wholesale. Its caveat is the honest one to record: the method is a per-repository *conditional oracle* — thin history degrades the signal, so history must be one fallible signal among several, never the sole authority. ### 2.7 Honest measurement: the SWE-Bench Illusion **The SWE-Bench Illusion** [9] is the reason this component's measurement section is written the way it is. Its diagnostic finding: state-of-the-art models name the correct buggy *file* from the *issue text alone*, with no repository in context, up to 76% of the time — a performance that can only come from memorization, not reasoning, and one that collapses outside SWE-bench. The implication is direct and uncomfortable: a substantial fraction of published SWE-bench localization performance is contaminated by weights that have seen the answer. For a harness builder the operational translation is a standing suspicion to harden against — any pipeline that "works suspiciously well on Django" may be reading from weights rather than from the repository. The countermeasures — held-out repositories, separated localization metrics, disclosed per-repo history — are codified in Section 6. Two context references complete the lineage. **SWE-bench** [1] supplies the task definition and the measurement substrate framing all of the above; it is cited for no single number. **AutoCodeRover** [3] is the earliest demonstration that localization can be partly deterministic — deterministic AST symbol search paired with spectrum-based fault localization before any model steps in — and is the lineage this component generalizes. ## 3. Design Principles Six principles follow from the review, each tied to the evidence above. **P1 — Hierarchical.** Localization proceeds files → entities → statements. Coarse granularity carries structure — a file's path, a function's signature, its callers and callees — and structure is cheap to compute and highly informative about whether a site *could* be the fault. Statement-level content is expensive and should be read only for candidates that survive the coarse ranking. Agentless's file → element → edit-location funnel [2] is the warrant for the shape; CoSIL's observation that fine-grained traversal is where the cost goes [6] is the warrant for spending it last. **P2 — Deterministic-first.** The initial candidate list is *never* language-model-generated. A fused deterministic pre-filter — lexical overlap, BM25, and at most a small (137M-class) bi-encoder that needs no GPU — shrinks the repository to a top-20-to-50 candidate set before any learned component sees a token. SweRank's 137M-retriever-beats-7B-embedders (and LocAgent/Claude-3.5) finding [4], and LLM4FL's purely-deterministic DepGraph ranking beating the language model outright [7], jointly warrant this: the deterministic ranker is not a fallback, it is the workhorse, and it can win. **P3 — Evidence-fused.** At least five independent signals are computed and combined: issue semantics (identifiers, error strings, natural-language description), structural evidence (AST identifiers and call-graph distance), dynamic evidence (SBFL/Ochiai coverage when a failing test exists), stack-trace evidence (the deepest non-library frame), and historical evidence (git churn hotspots and past issue-to-fix pairs). Each signal is fallible; their *agreement* is the strong signal. This is the explicit generalization of the single-signal designs in the review — each prior system's weakness is that it trusts one signal, and fusion is the cure. **P4 — The confidence test.** When the independent signals *agree* on a candidate, trust the consensus and stop — do not spend language-model tokens confirming what five signals already agree on. When they *disagree*, and only then, invoke the language model to adjudicate the ambiguity — and even then as a listwise re-ranker over the already-small shortlist, never as an explorer. SweRank's listwise-reranker-identifies-the-single-positive trick [4] defines exactly what the learned step may do. The target is stated concretely in Section 4: the learned column contains *at most one* entry, and in the common agreement case it is *zero*. **P5 — Lazy and structure-guided.** The structural graph is built incrementally, on demand, gated by relevance, and expanded by a priority-queue beam search over the call graph — with zero language model in the loop. CoSIL's relevance-gated BFS [6] supplies the structure; OrcaLoca's priority-queue scheduler [5] supplies the beam search; the difference from both is that this harness's gate is deterministic (Section 4), where theirs is a model scoring the frontier. **P6 — Honest measurement.** Localization is scored separately from repair, against ground-truth-from-patch metrics, on held-out and out-of-benchmark repositories, with per-repo git-history availability disclosed as a confound, and with the anti-leakage protocol of filtering overlapping-text issues and pre-date commits. The SWE-Bench Illusion [9] makes this non-negotiable; Repository Memory's anti-leakage protocol [8] supplies the concrete mechanics. ## 4. The Architecture The pipeline is a sequence of stages; every node is labeled D (deterministic software) or L (a learned model), and the invariant that governs the whole is: *the L column contains at most one entry, reached only on disagreement.* The flow, from symptom to site: 1. **Issue intake → signal mining [D].** The issue description is parsed, not interpreted. The miner extracts identifiers and API names (by lexical matching against the repository symbol table), the error message strings and stack trace, the deepest *non-library* frame (LLM4FL's stack-trace pruning [7], applied deterministically), and any reproduction steps. No language model reads the issue at this stage; the output is a structured bundle of five evidence channels, each independently computable. 2. **Fused deterministic pre-filter [D].** The five channels are each turned into a cheap ranking over the repository: BM25 over identifiers and error strings, lexical overlap on file/entity names, and — where the symbol table is large — a small bi-encoder in the 137M class, run on CPU, following SweRank's demonstration that this size beats the 7B embedders [4]. The channels are rank-combined (reciprocal-rank fusion) into a single candidate list, truncated to the top 20–50. This is the search-space reduction that makes everything downstream cheap. 3. **Lazy structural expansion [D].** From the candidate files' import graph, expand into the call graph with a relevance-gated, bounded BFS (at most 10 iterations, per CoSIL [6]), but with the gate replaced by a deterministic predicate: a path is pruned when its identifiers, error strings, and callee signatures show no overlap with the issue bundle, and expanded when they do. Priority is a beam search over a heap ordered by structural distance from the issue's named symbols (OrcaLoca's scheduler [5], de-LLM'd). The output is a structurally-connected candidate subgraph. 4. **Dynamic evidence [D, when tests exist].** If a failing test or reproduction exists, run it, collect coverage, and compute Ochiai suspiciousness over the covered methods (LLM4FL's order-aware segmentation [7], with its deterministic core retained and its reflective layer dropped). Sort the candidate subgraph by suspiciousness; prune external-library frames and truncate test bodies at the first failing assertion. When no failing test exists — the classic case — this stage is skipped and the remaining channels carry the weight, with the historical channel promoted (the "classic SBFL fallback" of Section 6). 5. **Historical evidence [D, when history exists].** Query the commit log for churn hotspots (top-K, K = 200, per Repository Memory [8]) and for past issue-to-fix pairs, retrieved by BM25 over commit messages with a lightweight tokenizer — no embeddings, no GPU, per [8]'s finding that this beats a dense retriever. Pre-date commits only, and overlapping-text issues filtered, per the anti-leakage protocol [8]. Output is a per-candidate historical prior; when history is thin, the prior is flat and flagged as such. 6. **Evidence fusion [D].** The channels are rank-combined into a single hierarchical ranking: files, then entities within files, then statements within entities. Each candidate carries a *causal story* assembled from the agreeing signals — "entity *e* fails because its state under condition *c* is inconsistent with what the callers at distance *d* assume, as evidenced by coverage suspiciousness *s* and history *h*." 7. **Confidence test [D] → conditional L.** The fused ranking is checked for *agreement*: do the top channels converge on the same site? If the top-k sites are mutually consistent across at least two independent channels and no channel strongly contradicts the leader, the pipeline *stops* and emits the top-k with their causal stories. If the channels disagree — semantic points one place, dynamic points another, history a third — the single learned step runs: a listwise language-model re-ranker that reads the *shortlist* (not the repository) and emits the identifiers it judges the true cause, using SweRank's observation that it need only predict the single positive [4]. It reads the shortlist, it emits IDs, and it does not explore. The target is therefore explicit and checkable: in the common agreement case the L column is *empty* and localization is deterministic software on CPU; in the disagreement case the L column holds exactly one entry — a shortlist re-ranker — and nothing else. Any proposed addition that would put a language model earlier in the pipeline is a regression against P2 and must clear a high bar: beat the deterministic ranker on the honest metrics of Section 6, on held-out repositories, at a defensible cost, or be rejected. ## 5. Recursive Self-Improvement Protocol Component 5 of 27 follows the program's uniform protocol: the executable specification is written to 100%, round 1 lands at approximately 80% of the specified behavior, and later rounds close the gap. Each round is A/B-gated against the honest metrics of Section 6 — never the end-to-end resolve rate, which would let repair quality mask localization quality. The deterministic stages (1–6) are improved by direct engineering, measured by ablation against the fused baseline; the single learned stage (7) is improved only if a candidate re-ranker beats the deterministic ranker on held-out repositories under the contamination controls. A stage may be *removed* when the A/B shows it does not move the honest metrics; the roadmap's design rule holds throughout — make the environment better at programming rather than prompting the model harder. ## 6. Measurement & Evaluation Localization is measured *separately* and *honestly*, in four instruments. **Ground-truth-from-patch metrics.** The true site is extracted from the merged patch itself — the file, entity, and statement the maintainer's fix actually touched — not from any model's claim. Against that ground truth, report file- and function-level recall@1/3/5, mean reciprocal rank (MRR), and *distance-to-edited-entity* (structural distance from the top-ranked candidate to the true site, rewarding "wrong function, right neighborhood" over a correct-looking wrong answer far away). These are the primary numbers; resolve rate is downstream and secondary. **The oracle-localization diagnostic.** Run repair twice: once with the *oracle* (ground-truth) locations supplied, once with the *retrieved* locations. The gap is the localization ceiling — the portion of resolve rate recoverable by improving localization alone. OrcaLoca's measured chain [5] shows this gap is real and quantifiable; this diagnostic turns it from a reported finding into a standing measurement. **The anti-memorization control.** Report localization on held-out and out-of-benchmark repositories — issues the model weights have not plausibly seen — and report the *drop* from in-benchmark to out-of-benchmark as a contamination indicator, per the SWE-Bench Illusion [9]. Any component whose localization "works suspiciously well on Django" but collapses elsewhere is flagged for memorization, not credited for reasoning. **Per-repo history disclosure.** Git-history availability is reported per repository, because Repository Memory's conditional-oracle caveat [8] means history-rich and history-poor repos are not the same measurement. Finally, the *classic SBFL fallback*: when no failing test exists, the pipeline must still emit a ranked list, and its quality on those cases — where dynamic evidence is absent and semantic/structural/historical carry the load — is reported as its own sub-metric, not silently averaged into the test-present cases. ## 7. Conclusion Fault localization is the stage that sets the ceiling on the entire coding-harness program, and the ceiling is set by search-space reduction, not by model strength. This paper has argued that the reduction should be performed hierarchically, by fusing independent evidence channels, and by a deterministic ranker that runs first and — on the published evidence — can beat the language model outright. The language model is confined to a single, conditional role: a listwise re-ranker over a shortlist, invoked only when the deterministic signals disagree, and never permitted to explore. The architecture labels every node deterministic or learned and enforces the invariant that the learned column is empty in the common case. Measurement is separated from repair, grounded in the merged patch, and hardened against the memorization contamination that inflates leaderboard numbers. For a weak model on CPU, the consequence is concrete: localization is deterministic software, the model's possible contribution is one disagreement-case adjudication, and the honest metrics — not the vibes — decide whether even that one is worth keeping. --- ## References 1. Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. *SWE-bench: Can Language Models Resolve Real-World GitHub Issues?* ICLR 2024. arXiv:2310.06770. 2. Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. *Agentless: Demystifying LLM-based Software Engineering Agents.* arXiv:2407.01489, 2024. *(Preprint.)* 3. Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. *AutoCodeRover: Autonomous Program Improvement.* ISSTA 2024. arXiv:2404.05427. 4. Revanth Gangi Reddy, Tarun Suresh, JaeHyeok Doo, Ye Liu, Xuan-Phi Nguyen, Yingbo Zhou, Semih Yavuz, Caiming Xiong, Heng Ji, and Shafiq Joty. *SweRank: Software Issue Localization with Code Ranking.* ICLR 2026. arXiv:2505.07849. *(2025 preprint → ICLR 2026.)* 5. Zhongming Yu, Hejia Zhang, Yujie Zhao, Hanxian Huang, Matrix Yao, Ke Ding, and Jishen Zhao. *OrcaLoca: An LLM Agent Framework for Software Issue Localization.* ICML 2025. arXiv:2502.00350. *(2025 preprint → ICML 2025.)* 6. Zhonghao Jiang, Xiaoxue Ren, Meng Yan, Wei Jiang, Yong Li, and Zhongxin Liu. *CoSIL: Software Issue Localization via LLM-Driven Code Repository Graph Searching.* ASE 2025. arXiv:2503.22424. *(2025 preprint → ASE 2025.)* 7. Md Nakhla Rafi, Dong Jae Kim, Tse-Hsun (Peter) Chen, and Shaowei Wang. *LLM4FL: Enhancing Fault Localization Through Ordered Code Analysis with LLM Agents and Self-Reflection.* arXiv:2409.13642, 2024. *(Note: the correct arXiv ID is 2409.13642; an earlier citation as 2409.13662 is wrong.)* 8. Boshi Wang, Weijian Xu, Yunsheng Li, Mei Gao, Yujia Xie, Huan Sun, and Dongdong Chen. *Improving Code Localization with Repository Memory.* ICLR 2026. arXiv:2510.01003. *(2025 preprint → ICLR 2026.)* 9. Shanchao Liang, Spandan Garg, and Roshanak Zilouchian Moghaddam. *The SWE-Bench Illusion: When State-of-the-Art LLMs Remember Instead of Reason.* arXiv:2506.12286, 2025. *(Preprint.)*