Bug Report Specification Refinement with Trajectory Guidance for Automated Program Repair S M Farah Al Fahim∗ , Md Nakhla Rafi∗ , Md Ahasanuzzaman∗ , Zeyang Ma∗ Dong Jae Kim† , Shaowei Wang‡ , Tse-Hsun (Peter) Chen∗ ∗ Software Performance, Analysis, and Reliability (SPEAR) Lab, Concordia University, Montreal, Canada
arXiv:2607.07882v1 [cs.SE] 8 Jul 2026
[email protected], [email protected], m [email protected] m [email protected], [email protected] † DePaul University, Chicago, USA [email protected] ‡ University of Manitoba, Winnipeg, Canada [email protected] Abstract—Bug reports serve as task specifications for repository-level automated program repair (APR) agents, but they often describe only the observed failure and omit repairrelevant information such as the failure-inducing behavior, behavioral requirement, and implementation scope. As a result, a repair agent may inspect irrelevant code, infer an incorrect requirement, or generate a patch that addresses the reported symptom without restoring the intended repository behavior. We present TrajSpec, a trajectory-guided approach for repository-supported bug report specification refinement. Given an original report and a prefix repository, TrajSpec runs a trajectory-collection agent and uses the resulting unverified trajectory as a source of trajectoryderived specification evidence. It organizes this evidence into a three-level representation consisting of a high-level interpretation of the issue, diagnostic findings supporting that interpretation, and concrete repository observations. TrajSpec then generates a draft refined report and applies repository-based review to remove unsupported claims, revise uncertain claims, and add repository-supported details. We evaluate TrajSpec on all 300 SWE-Bench Lite instances using Mini-SWE-Agent V2. TrajSpec’s refined reports improve Pass@1 from 41.00% to 59.67% with GPT-5-mini and from 54.67% to 64.33% with MiniMax M2.5. On a stratified sample of 100 instances, TrajSpec’s refined reports also improve Pass@1 from 41.00% to 71.00% with Agentless and from 47.00% to 72.00% with AutoCodeRover. Ablation results show that removing repository-based review or the hierarchical evidence representation reduces Pass@1 from 59.67% to 48.00% and 47.67%, respectively. Overall, TrajSpec provides actionable repository-supported context that consistently improves repair performance. Index Terms—Automated Program Repair, Bug Report Enhancement, Specification Refinement, Large Language Models, Repository-Level Repair, Software Maintenance
I. I NTRODUCTION Large language models (LLMs) have enabled a new generation of repository-level automated program repair (APR) agents [1, 2, 3, 4, 5]. Given a bug report and a pre-fix repository snapshot, these agents search the repository, inspect source code, reason about the expected behavior, and generate patches that are validated against tests. Benchmarks such as SWE-Bench [6] have made this setting a central testbed for evaluating whether LLM-based agents can resolve real software issues from open-source repositories. In this setting, a bug report is not only a communication artifact for developers. It is the primary task specification from which the repair agent
must infer what behavior is wrong, what behavior should hold, and which parts of the repository are relevant to the fix. However, the information needed to describe the symptoms of a bug is not necessarily sufficient to guide repository-level repair. Prior work has identified report elements that support bug understanding and diagnosis, including reproduction steps, observed and expected behavior, affected components, stack traces, logs, and other diagnostic information [7, 8, 9, 10, 11, 12]. These elements help describe where and how a failure manifests, but they may not specify the repository-level behavior important for repair. In particular, the report may leave implicit the relevant implementation logic, the constraints that a correct fix must preserve, and the scope over which the expected behavior should hold. Human developers can recover such information through project knowledge, followup discussion, and repository exploration. A repair agent must instead infer it from the report and the pre-fix repository. When this inference is incomplete or incorrect, the agent may inspect irrelevant code, infer the wrong requirement, or generate a patch that removes the reported symptom without restoring the intended behavior [13, 14]. Such incomplete or underspecified reports expose a specification problem in repository-level APR. Most recent work improves the repair agent through better search, localization, prompting, planning, or patch generation [15, 2, 16, 1, 17, 18, 19]. These improvements are important, but they still assume that the input report provides a sufficient task specification. Prior work has also explored report structuring, crash reproduction from stack traces, duplicate grouping, fault localization, and LLM-based report rewriting [20, 21, 22, 23]. These approaches make reports easier to read or connect reports to code artifacts, but they do not directly refine the report by gathering the repair specification needed by a downstream APR agent. The missing step is to expose the repair-relevant details that the report leaves implicit before downstream repair begins. A trajectory-collection run can help recover some missing specification elements. When the trajectory-collection agent explores the repository for an underspecified report, its trajectory records the agent’s search, code inspection, tool use, hypotheses, and revisions to its interpretation of the issue.
Even without knowing whether any resulting candidate patch is correct, the trajectory can provide repository-supported evidence for refining the report, including relevant code locations, dependencies among affected components, and behavioral constraints that were not explicit in the original report. However, raw trajectories are long, noisy, and unverified. They may include failed searches, repeated observations, abandoned hypotheses, weakly supported claims, and patchconstruction details that should not be copied into the task specification. This creates a specification-refinement challenge: the method must recover useful repair specification evidence from the trajectory, keep high-level diagnoses connected to concrete repository observations, and review generated claims against the pre-fix repository before the refined report is given to a downstream repair agent. We present TrajSpec, a trajectory-guided approach for repository-supported specification refinement. Given an original bug report b and a pre-fix repository snapshot Rc , TrajSpec runs a trajectory-collection agent using only b and Rc . As TrajSpec does not validate any candidate patch produced during this trajectory-collection run, it discards any such patch and retains only the execution trajectory τ . It then extracts specification evidence from b and τ , focusing on three repairrelevant dimensions: the failure mechanism, the behavioral requirement, and the implementation scope. To preserve both diagnostic structure and source-code evidence, TrajSpec organizes this evidence into a hierarchical representation M with progressively finer levels of detail: a high-level candidate interpretation, diagnostic relationships, and concrete repository observations. TrajSpec then generates a draft refined report b̂ from b and M , and applies repositorybased review against Rc to remove unsupported claims, revise uncertain statements, and add repository-supported details that were omitted. The resulting report b̂f serves as the repositorysupported specification supplied to the downstream repair agent. This design separates trajectory use from patch trust. TrajSpec does not assume that any candidate patch produced during the trajectory-collection run is correct, and it does not use the developer patch, post-fix repository, or benchmark outcome during specification refinement. We evaluate TrajSpec on all 300 SWE-Bench Lite [6] instances using Mini-SWE-Agent V2 [16] as the primary downstream repair agent. With GPT-5-mini, TrajSpec improves Pass@1 from 41.00% using the original reports to 59.67%. With MiniMax M2.5, it improves Pass@1 from 54.67% to 64.33%. To evaluate whether the refined reports remain useful beyond the primary downstream repair agent, we further evaluate TrajSpec’s refined reports on a stratified sample of 100 instances using Agentless [15] and AutoCodeRover [2]. TrajSpec improves Agentless from 41.00% to 71.00% and AutoCodeRover from 47.00% to 72.00%. Our ablation study shows that all the main components of TrajSpec are important. Removing repository-based review reduces Pass@1 from 59.67% to 48.00%, while removing the hierarchical evidence representation reduces it to 47.67%. These results show that trajectory-guided specification refinement with repository-
based review provides more informative diagnostic context for repository-level repair. In summary, this paper makes the following contributions: We formulate bug report enhancement for repositorylevel APR as repository-supported specification refinement, where the goal is to make explicit the failure mechanism, behavioral requirement, and implementation scope needed for repair. • We introduce TrajSpec, a trajectory-guided approach that extracts and hierarchically organizes specification evidence from the trajectory produced by an unverified trajectory-collection run, reviews the evidence against the source code, and generates a refined report. • We evaluate TrajSpec on all 300 SWE-Bench Lite [6] instances using Mini-SWE-Agent V2 [16] and show that its refined reports improve Pass@1 from 41.00% to 59.67% with GPT-5-mini and from 54.67% to 64.33% with MiniMax M2.5. • We show that the benefits of TrajSpec generalize across downstream repair agents. On a stratified sample of 100 instances, TrajSpec improves Pass@1 from 41.00% to 71.00% for Agentless [15] and from 47.00% to 72.00% for AutoCodeRover [2]. • We conduct ablation and cost analysis showing that repository-based review and hierarchical evidence abstraction both substantially contribute to repair performance, while the additional preprocessing cost remains practical relative to the repair gains. •
Our findings show a promising direction for improving repository-level repair: not only making repair agents stronger, but also improving the task specifications that guide them. Paper Organization. Section II discusses related work. Section III presents a motivating example. Section IV describes the design of TrajSpec. Section V reports the evaluation results. Section VI discusses threats to validity. Finally, Section VII concludes the paper. II. R ELATED W ORK This section discusses prior work on bug-report enhancement, repository-level automated program repair (APR), and reuse of repair knowledge. Bug Report Quality, Structuring, and Enhancement. Prior work has established that the information contained in a bug report affects how effectively developers can diagnose and resolve an issue. Developers particularly value reproduction steps, stack traces, and test cases [7], and the presence of reproduction steps, stack traces, and fix suggestions can influence resolution time [8]. Building on these findings, subsequent work improves bug reports by reorganizing their existing content or recovering missing diagnostic information. Rastkar et al. [20] summarize lengthy bug reports, while Acharya and Ginde [23] transform unstructured reports into structured templates. LLPut [24] extracts failure-inducing inputs from report text, and Fahim et al. [25] enrich crash reports using
stack traces and source-code context. These approaches improve the presentation or diagnostic content of a report using information available in the report and related artifacts. In contrast, TrajSpec uses the trajectory produced by a trajectorycollection run to recover repair-relevant information that may not be explicit in the original report to better guide automated repair. Enhancing Repository-Level APR. Recent approaches improve repository-level APR by clarifying the repair task, constructing repair guidance, or providing additional repository context for patch generation [13, 4, 5, 26, 27, 14]. CodeScout [13] enriches underspecified tasks through static repository pre-exploration before downstream repair. A broader line of work helps agents acquire and organize repair-relevant context without rewriting the issue. SWE-Agent [1] and RepairAgent [3] support iterative repository exploration, tool use, patch generation, and validation. Agentless [15] separates localization, repair, and validation, whereas AutoCodeRover [2] combines LLM reasoning with structure-aware code search and test-based localization. Other approaches produce explicit artifacts to guide repair: SGAgent [4] and SHERLOC [5] generate diagnostic guidance, while KGCompass [26] and RepoRepair [27] represent repository knowledge through knowledge graphs or hierarchical code documentation. TrajSpec differs in both its evidence source and its objective. CodeScout [13] derives task context from static repository preexploration, while agentic APR systems collect context as part of the final repair run. In contrast, TrajSpec extracts specification evidence from the ordered trajectory of an unverified trajectory-collection run without assuming that any candidate patch from that run is correct. It hierarchically organizes this trajectory-derived evidence and reviews the resulting claims against the pre-fix repository before producing a refined report for downstream repair. Reuse of Repair Knowledge. Recent work studies how knowledge from previously resolved issues can guide repository-level repair. ExpeRepair [28] derives reusable memories and semantic insights from historical repair trajectories, while ConRAD [29] reconstructs stage-wise repair reasoning from verified historical patches. SWE-ContextBench [30] evaluates whether coding agents can retrieve and reuse relevant context from related issues. These approaches transfer knowledge across issues. In contrast, TrajSpec extracts specification evidence from the trajectory produced by an unverified trajectory-collection run for the current issue and uses it to refine the bug report before downstream repair. TrajSpec in Relation to Prior Work. Overall, TrajSpec connects bug-report enhancement with repository-level repair. Prior work typically improves reports using information already present in the report or related artifacts, or uses repository context directly during patch generation. TrajSpec instead uses the trajectory produced by an unverified trajectorycollection run to uncover missing specification details and incorporates them into a refined report for downstream repair. It also differs from methods that reuse past repairs because the
evidence comes from the current issue and does not depend on any patch from the trajectory-collection run being correct. III. A M OTIVATING E XAMPLE A bug report can describe a visible failure while omitting repair-relevant behavior that is evident in the repository. Consider astropy-14365, a real-world GitHub issue from the Astropy project included in the SWE-Bench Lite benchmark [6]. Figure 1 presents simplified excerpts from the original bug report and the refined report produced by TrajSpec. The original report provides two useful pieces of specification information: the observed failure, in which the reader rejects a lowercase QDP command, and the expected behavior, in which commands should be accepted regardless of capitalization. However, the original report does not explain the specific code behavior responsible for the failure or identify the full scope of the parsing logic affected by the same case-sensitivity assumption. The developer repair, shown in simplified form in Listing 1, illustrates why the additional information in the refined report is useful. The repair modifies two locations. First, it makes command classification in _line_type case-insensitive, directly addressing the reported failure. Second, it makes the handling of the masked-value token NO case-insensitive in _get_tables_from_qdp_file. This second location is not mentioned in the original report, although it embodies the same uppercase-only parsing assumption. Listing 1: Simplified developer repair for astropy-14365. The first change addresses the reported command failure, while the second applies the same case-insensitive behavior to a related parsing location omitted in the original report. # Reported behavior: command classification in _line_type # Before: matching is case-sensitive _line_type_re = re.compile(_type_re) # After: commands are matched regardless of case _line_type_re = re.compile(_type_re, re.IGNORECASE) # Related behavior: masked-value parsing in _get_tables_from_qdp_file # Before: only uppercase "NO" is recognized if v == "NO": values.append(np.ma.masked) # After: the token is recognized regardless of case if v.upper() == "NO": values.append(np.ma.masked)
A repair agent guided only by the original report is naturally directed toward the visible command-classification failure. It may correctly modify the regular expression so that read serr 1 2 matches the same parser rule as READ SERR 1 2. Such a repair addresses the reported symptom but can remain incomplete: the report does not indicate that the comparison v == "NO" represents a related instance of the same case-sensitive parsing behavior. Discovering this second location, therefore, requires reasoning beyond the explicit contents of the report. Indeed, the developer patch modifies both
Original bug report excerpt
TrajSpec refined report excerpt
Reported issue: QDP commands are incorrectly casesensitive.
Title. ascii.qdp reader treats QDP commands and masked token NO as case-sensitive.
Expected behavior. Because QDP commands are caseinsensitive, the ascii.qdp reader should accept both READ SERR 1 2 and read serr 1 2. Observed behavior. Reading a file containing the lowercase command read serr 1 2 1 0.5 1 0.5 causes the reader to fail with ValueError: Unrecognized QDP line: read serr 1 2
Description. The reader recognizes QDP commands and masked values in a case-sensitive way. Lowercase or mixedcase commands such as read serr 1 2, and masked tokens such as no, may therefore cause parsing failures or incorrect data interpretation. RootCause. The issue is caused by uppercase-only assumptions in related parsing logic: (1) command matching in _line_type is compiled without case-insensitive matching, and (2) masked-value parsing in _get_tables_from_qdp_file checks only the exact token NO. StepsToReproduce. Create test.qdp containing read serr 1 2 Table.read(’test.qdp’, format=’ascii.qdp’).
and
1 0.5 1 0.5,
then
run
ExpectedBehavior. QDP control commands such as read serr 1 2 and masked-value tokens such as no, No, or NO should be accepted irrespective of case. ObservedBehavior. The reader raises ValueError for lowercase commands, and lowercase or mixed-case masked tokens are not treated as masked values.
Fig. 1: Simplified before-and-after report excerpts for astropy-14365. The original report describes the visible lowercasecommand failure, while the refined report preserves the reported failure and expected behavior and adds repository-supported information about the failure mechanism, behavioral requirement, and implementation scope.
locations, showing that the intended repair extends beyond the failure explicitly described in the report. These missing specification elements could guide the repair agent toward a more complete fix, but they are not available in the original report. A trajectory-collection run can expose such elements because its trajectory records the agent’s code inspections, search decisions, and intermediate reasoning while it tries to explain the reported failure. In this example, the trajectory shows how reasoning starts from the reported command-matching failure and moves to related parsing logic that contains the v == "NO" comparison. TrajSpec therefore analyzes the trajectory produced by an unverified trajectory-collection run to recover evidence about the failure mechanism, broader behavioral requirement, and affected code locations. It then structures and reviews this evidence against the pre-fix repository to produce a refined report for downstream repair. IV. TrajSpec: T RAJECTORY-G UIDED S PECIFICATION R EFINEMENT TrajSpec addresses the problem of underspecified bug reports by using the trajectory produced by an unverified trajectory-collection run to recover trajectory-derived specification evidence. Given an original bug report b and its pre-fix repository snapshot Rc , TrajSpec runs a trajectory-collection agent using only b and Rc , and retains the resulting execution trajectory τ . The trajectory records the agent’s repository searches, inspected source code, tool invocations, observations, and intermediate reasoning. From b and τ , TrajSpec extracts repair-relevant observations about three missing specification elements: the failure mechanism, the behavioral requirement, and the affected implementation scope. It organizes these observations into a hierarchical specification M , generates a draft refined report b̂, and reviews the draft against the pre-fix repository Rc to remove unsupported claims, revise uncertain statements, and add repository-supported details. The resulting report b̂f is supplied to the downstream repair agent as the task
specification for final patch generation. Figure 2 provides an overview of TrajSpec. A. Collecting Specification Evidence from a TrajectoryCollection Run To recover specification missing from the original report, TrajSpec performs an unverified trajectory-collection run on the original bug report b and pre-fix repository snapshot Rc using a trajectory-collection agent. The agent performs repository-level exploration for the reported issue: it searches the repository, inspects source code, executes available tools, reasons about candidate failure explanations, and records each thought-action-observation step. This run produces the execution trajectory τ and may also produce a candidate patch. TrajSpec, however, is agnostic to the specific trajectory source: it requires only τ , not the candidate patch or the agent’s internal implementation, so any repository-level agent that exposes such a trajectory can potentially serve as the trajectory source. To avoid data leakage, the trajectory-collection agent has no access to the developer patch, post-fix code, or benchmark test outcome. We call the trajectory-collection run unverified because TrajSpec does not validate whether any resulting patch is correct during specification refinement. Any candidate patch is therefore discarded, and only τ is retained. We keep τ because it records the agent’s repository interactions, intermediate reasoning, and repair decisions, which can provide trajectory-derived specification evidence regardless of whether the patch was correct. We represent τ as an ordered sequence of thought–action– observation tuples [31]: τ = ⟨(t1 , a1 , o1 ), . . . , (tn , an , on )⟩, where each tuple records one agent-environment interaction step. The thought ti records the agent’s stated diagnostic reasoning, ai denotes the corresponding repository or tool action, and oi denotes the resulting observation. An action may search for a program entity, inspect or modify source code, or execute an available tool. An observation may contain search
Input
Inputs
Original Report
b
Pre-fix Rc Repository
Generated artifact
Trajectory Collection
Discarded artifact
LLM component
Execution Trajectory τ
Evidence Extraction
Hierarchical Evidence M
thought–action–observation
from b + τ
3 branches × 3 levels
Repository-Based Review
Draft Refined Report b̂
Report Generator
from b + b̂ + M + Rc
fixed schema
from b + M
discarded
Candidate Patch dropped — not trusted
To downstream
repair agent
Final Refined Report b̂f
add · remove · revise
reviewed
Fig. 2: Overview of TrajSpec. Given an original bug report b and the pre-fix repository snapshot Rc , TrajSpec produces a final refined report b̂f that serves as a repository-supported specification for downstream repair. TrajSpec first runs a trajectorycollection agent using only b and Rc , discards any candidate patch produced during this run, and retains the execution trajectory τ . It then uses b and τ to recover specification evidence and structure it into a hierarchical evidence representation M . Finally, TrajSpec generates a draft refined report b̂ from b and M , and applies repository-based review using b, b̂, M , and Rc to produce the final refined report b̂f . results, retrieved source code, execution feedback, or other tool output. The observation oi can inform subsequent reasoning and actions, allowing the ordered trajectory to preserve how the agent’s interpretation and candidate repair evolve during the run. Although the run is unverified, its trajectory can still expose information useful for refining the report. It records how the trajectory-collection agent attempts to resolve ambiguities in the original report and construct a working specification of the issue. This information may include the failure behavior observed by the agent, the files, methods, or APIs it associates with the failure, the inputs or configurations under which the behavior occurs, behavior suggested by analogous implementations, and constraints that a final repair should preserve. At the same time, the trajectory may contain irrelevant searches, unsupported hypotheses, abandoned diagnoses, weakly supported conclusions, and patch-construction details that do not contribute to the specification. TrajSpec therefore treats τ as a noisy source of trajectory-derived specification evidence, rather than as a specification or trusted repair, and passes it to the hierarchical evidence-abstraction step.
Specification Evidence Extraction. TrajSpec uses a structured LLM-based abstraction prompt to extract candidate findings from b and τ . Rather than summarizing the trajectory chronologically, the prompt retains observations that help reconstruct: 1) the failure mechanism, or the sourcecode behavior that may explain the reported symptom; 2) the behavioral requirement, or the behavior that should hold in the reported scenario; and 3) the implementation scope, or the code locations that implement, depend on, or otherwise participate in that behavior. We denote the extracted findings and repository observations as E. The LLM omits routine tool interactions, repeated observations, failed lookups, and details unrelated to understanding the issue. It retains intermediate findings when they support a candidate specification claim, connect multiple code locations, or reveal an unresolved gap. Because τ is produced by an unverified trajectory-collection run, however, E may contain weakly supported claims, incomplete evidence, or conflicting interpretations. TrajSpec therefore treats the extracted findings as candidates to be examined during the subsequent repositorybased review.
B. Hierarchical Specification Evidence Abstraction
Hierarchical Evidence Representation. TrajSpec organizes E into three evidence branches:
The execution trajectory τ produced in §IV-A can be lengthy and noisy. Passing it directly to specification generation may obscure relevant findings, whereas compressing it into a flat summary may discard repository details needed to support the generated specification. TrajSpec therefore transforms the original bug report b and trajectory τ into a hierarchical evidence representation M . It first extracts candidate repository findings E and then organizes them into evidence structures supporting three aspects of the missing specification: the failure mechanism, behavioral requirement, and implementation scope.
M = (Mmech , Mreq , Mscope ) , where Mmech , Mreq , and Mscope contain evidence concerning the candidate failure mechanism, behavioral requirement, and implementation scope, respectively. Each branch is represented at three levels: Mj = (Mj,hi , Mj,mid , Mj,lo ) ,
j ∈ mech, req, scope.
Table I gives an illustrative example of this representation using the QDP motivating example based on Figure 1. In this representation, for each specification aspect j, Mj,hi states
TABLE I: An illustrative example of the hierarchical evidence representation. Level
Failure mechanism
Behavioral requirement
Implementation scope
High
Case-sensitive QDP parsing
Mid
Multiple parser checks assume uppercase input Missing regex flag and exact "NO" comparison
Accept tokens regardless of capitalization Handle commands and masked values case-insensitively Recognize lowercase commands and masked tokens
Apply the behavior consistently across the reader Update both command and maskedtoken parsing Relevant functions and tests in qdp.py
Low
the candidate specification-level conclusion. Mj,mid captures the diagnostic reasoning that supports the conclusion, such as relationships among code paths, shared behavioral patterns, or dependencies between affected locations. Mj,lo retains the concrete repository observations that support this reasoning, including relevant files, functions, variables, conditions, and constants. Thus, the three branches distinguish the content of the reconstructed specification, while the three levels preserve how repository observations support specification-level conclusions. C. Specification Generation and Repository-Based Review The hierarchical evidence representation, M , organizes candidate specification evidence, but it is not yet a refined report. Its information remains distributed across high-level interpretations, diagnostic relationships, and concrete repository observations. Because this evidence comes from a useful but unverified trajectory, TrajSpec must separate candidate report content from unsupported assumptions before giving the refined report to a downstream repair agent. TrajSpec therefore converts M , together with the original bug report b, into a draft refined report b̂, and then applies repository-based review against the pre-fix repository Rc to produce the final refined report b̂f . Draft Specification Generation. Given the original bug report b and hierarchical evidence representation M , TrajSpec invokes an LLM to generate a draft refined report b̂. The report follows a fixed schema with fields that prior work has found useful for bug understanding, diagnosis, and reproduction [7, 8, 11, 12, 25]. The schema includes Title, Description, RootCause, StepsToReproduce, ExpectedBehavior, and ObservedBehavior. The fields play distinct roles. Title and Description summarize the reported issue and its manifestation. ObservedBehavior describes the behavior exhibited by the pre-fix implementation. ExpectedBehavior states the behavioral requirement that should hold for the reported scenario. RootCause records the candidate failure mechanism, implementation scope, and repository-supported details that explain the observed failure. StepsToReproduce is populated only when the original report b or hierarchical evidence representation M supports concrete reproduction steps. This schema separates the externally visible failure from the repository-level diagnosis and keeps the report focused on the issue rather than on a prescribed code change.
Specification Review and Report Revision. Because both the draft report b̂ and its supporting evidence representation M ultimately depend on the unverified trajectory τ , TrajSpec performs a repository-based review on b̂ before producing the final refined report b̂f . The reviewer is an LLM-based component provided with the original report b, the draft report b̂, and the hierarchical evidence representation M . It also has read-only tools for searching and inspecting the pre-fix repository Rc . The reviewer uses M as a structured index of candidate claims, diagnostic relationships, and relevant source locations. For each substantive claim introduced in b̂, the reviewer assesses whether the claim is supported by the evidence recorded in M and, where necessary, inspects the referenced source code in Rc to validate that support. The review considers four properties: whether added claims have adequate repository support, whether relevant findings in M have been omitted, whether the stated implementation scope is appropriately bounded, and whether each claim is expressed with certainty proportional to the available evidence. The reviewer gives particular attention to behavioral requirements. Requirements explicitly stated in the original report b are preserved as reported expectations, whereas requirements reconstructed from M are treated as inferred claims. An inferred requirement is retained only when it is supported by repository behavior observed in Rc , and is expressed as the behavior that should hold rather than as verified post-fix behavior. When evidence is insufficient, the reviewer removes the claim, revises its wording to reflect uncertainty, or limits it to the supported scope. When the draft report b̂ omits a relevant repository-supported finding, the reviewer adds it. Unresolved gaps remain marked as uncertain rather than being converted into definitive claims. This review improves the evidential support, coverage, and internal consistency of b̂, but it does not establish ground-truth correctness because neither the developer patch nor the benchmark test outcome is available. The resulting report b̂f is then provided to the downstream repair agent for repair. V. E VALUATION We evaluate TrajSpec on SWE-Bench Lite [6], a 300instance subset of SWE-Bench that provides a more costefficient evaluation of repository-level APR. Each instance is derived from a real-world GitHub issue and includes the
corresponding issue report, a pre-fix repository snapshot, and a test oracle for validating generated patches. We measure repair performance using Pass@1, the percentage of instances for which the first generated patch passes the test oracle. Our four research questions evaluate downstream repair effectiveness, cross-agent generalization, component contributions, and computational cost. RQ1: How effective are TrajSpec’s refined bug reports at improving automated program repair performance? Motivation. Repository-supported specification refinement is useful only if the resulting refined bug report provides actionable guidance for resolving the underlying bug. In our setting, this guidance connects the observed failure to its failure mechanism, the behavioral requirement that should hold, and the implementation scope involved. Because repair agents use the bug report as the initial problem description for generating a patch, automated program repair provides a natural downstream evaluation of whether TrajSpec’s refined bug reports contain diagnostic information that helps generate correct patches. RQ1 therefore evaluates the extent to which TrajSpec improves repair performance through repositorysupported specification refinement. Approach. For each bug instance, we evaluate the repair performance obtained using TrajSpec’s refined reports against two baseline report variants: the original reports and the Agentic-Base reports. Note that the downstream repair agent remains completely identical, and the only difference is the bug report we use as input. Original report: The bug report provided by SWE-Bench Lite [6]. Agentic-Base report: A trajectory-based report-enhancement baseline. We use this trajectory-based baseline, rather than a report-only rewrite baseline, because prior work shows that additional task evidence improves report enhancement and repair guidance [32, 33, 25, 34]. Given the original bug report b, this baseline uses the same trajectory-collection agent as TrajSpec to collect the raw execution trajectory τ . The reportgeneration model then receives b and τ directly to produce the raw refined report b̂raw . Unlike TrajSpec, this baseline does not construct the hierarchical evidence representation M or perform repository-based review. TrajSpec report: The refined bug report generated by TrajSpec following the repository-supported specification refinement approach described in Section IV, including hierarchical evidence abstraction and repository-based review. We select Mini-SWE-Agent V2 [16] as our primary downstream repair agent because it provides a lightweight yet capable workflow for repository-level automated program repair and has been commonly used in prior studies [35, 36, 37, 38, 39, 40]. To examine whether the effect of report refinement is consistent across model backbones, we run Mini-SWE-Agent V2 with two LLMs: GPT-5-mini (gpt-5-mini-2025-08-07) [41] and MiniMax M2.5 (minimax-m2.5) [42]. For each LLM setting, the generated reports are produced with the same backbone used for
downstream repair: GPT-5-mini performs all LLM calls in the GPT-5-mini setting, including trajectory collection, evidence extraction, hierarchical evidence abstraction, draft report generation, and repository-based review, while MiniMax M2.5 performs the same components in the MiniMax M2.5 setting. We select these two LLMs because they provide strong coding and agentic capabilities at practical API cost: GPT-5-mini is designed for cost-sensitive, high-volume workloads, while MiniMax M2.5 targets coding and agentic tasks with low token pricing [41, 42]. Results. TrajSpec reports improve Pass@1 over the original reports by 45.53% with GPT-5-mini and 17.68% with MiniMax M2.5. Table II reports the Pass@1 repair results. Since the downstream repair agent remains unchanged, the differences in Pass@1 reflect the effect of changing the report given to the agent. With GPT-5-mini, Mini-SWE-Agent V2 achieves 41.00% Pass@1 using the original reports and 48.67% using Agentic-Base reports. TrajSpec reports increase Pass@1 to 59.67%, corresponding to a 45.53% relative improvement over the original reports and a 22.60% relative improvement over Agentic-Base reports. With MiniMax M2.5, the original reports already provide a stronger starting point, achieving 54.67% Pass@1, while Agentic-Base reports achieve 53.00%. TrajSpec reports further increase Pass@1 to 64.33%, corresponding to a 17.68% relative improvement over the original reports and a 21.38% relative improvement over Agentic-Base reports. This contrast shows that Agentic-Base reports improve Pass@1 in one setting but not the other, whereas TrajSpec reports improve repair performance with both LLM backbones. TrajSpec reports consistently improve repair performance across repositories. The repository-level results show that TrajSpec reports improve repair performance across repositories. With GPT-5-mini, TrajSpec reports outperform the original reports in 11 of 12 repositories and Agentic-Base reports in 10 repositories. Flask instances are unresolved by all report variants, while TrajSpec reports tie Agentic-Base reports on pytest. A similar pattern appears with MiniMax M2.5. TrajSpec reports achieve the best or tied-best Pass@1 in every repository, improving over the original reports in eight repositories and over Agentic-Base reports in 10 repositories. These results show that the benefit of TrajSpec’s repositorysupported refined reports is broadly distributed across projects and is not driven by gains in only a small number of repositories. TrajSpec reports expand repair coverage while preserving almost all previously repaired instances. Figure 3 compares the instances repaired using the three report variants. With GPT-5-mini, every instance repaired using either the original reports or Agentic-Base reports is also repaired using TrajSpec reports. In total, TrajSpec reports repair 179 instances (11 + 112 + 34 + 22), including 22 instances that neither comparison report repairs. Thus, with GPT-5-mini, the gains from TrajSpec reports come entirely from expanding repair coverage rather than replacing previously repaired instances. A similar pattern appears with MiniMax M2.5. In total,
TABLE II: Repair performance of Mini-SWE-Agent V2 using original reports, Agentic-Base reports, and TrajSpec’s refined reports. Results are reported as resolved bugs and Pass@1 percentages. For each repository and LLM backbone, the bestperforming report variant is highlighted in bold. GPT-5-mini
Repository
MiniMax M2.5
Original
Agentic-Base
TrajSpec
Original
Agentic-Base
TrajSpec
astropy (6) django (114) matplotlib (23) seaborn (4) flask (3) requests (6) xarray (5) pylint (6) pytest (17) scikit-learn (23) sphinx (16) sympy (77)
3 (50.00%) 58 (50.88%) 10 (43.48%) 1 (25.00%) 0 (0.00%) 2 (33.33%) 1 (20.00%) 1 (16.67%) 3 (17.65%) 11 (47.83%) 8 (50.00%) 25 (32.47%)
4 (66.67%) 69 (60.53%) 11 (47.83%) 1 (25.00%) 0 (0.00%) 3 (50.00%) 1 (20.00%) 1 (16.67%) 4 (23.53%) 12 (52.17%) 8 (50.00%) 32 (41.56%)
5 (83.33%) 82 (71.93%) 14 (60.87%) 2 (50.00%) 0 (0.00%) 6 (100.00%) 2 (40.00%) 2 (33.33%) 4 (23.53%) 14 (60.87%) 10 (62.50%) 38 (49.35%)
3 (50.00%) 72 (63.16%) 11 (47.83%) 3 (75.00%) 0 (0.00%) 3 (50.00%) 2 (40.00%) 2 (33.33%) 7 (41.18%) 14 (60.87%) 9 (56.25%) 38 (49.35%)
4 (66.67%) 71 (62.28%) 11 (47.83%) 2 (50.00%) 0 (0.00%) 3 (50.00%) 2 (40.00%) 2 (33.33%) 7 (41.18%) 13 (56.52%) 8 (50.00%) 36 (46.75%)
5 (83.33%) 83 (72.80%) 13 (56.52%) 3 (75.00%) 1 (33.33%) 6 (100.00%) 2 (40.00%) 2 (33.33%) 9 (52.94%) 17 (73.91%) 9 (56.25%) 43 (55.84%)
Total (300)
123 (41.00%)
146 (48.67%)
179 (59.67%)
164 (54.67%)
159 (53.00%)
193 (64.33%)
GPT-5-mini
MiniMax M2.5
0
0
0
0
3
112 11
RQ2: Do TrajSpec’s refined reports improve repair performance across different downstream repair agents? 0
144 34
17
22
15 17
Original
Agentic-Base
TrajSpec
Fig. 3: Overlap of repaired SWE-Bench Lite instances across the three report variants.
TrajSpec reports repair 193 instances (17 + 144 + 15 + 17). They preserve 161 of the 164 instances repaired using the original reports (17 + 144 out of 3 + 17 + 144) and all 159 instances repaired using Agentic-Base reports (144 + 15). At the same time, TrajSpec reports repair 32 additional instances beyond the original reports (15 + 17), including 17 instances that neither comparison report repairs. The three regressions are resolved upon rerunning, suggesting that they result from run-to-run variation rather than a systematic loss caused by the refined reports. These results show that TrajSpec reports mostly expand the set of repaired bugs while preserving almost all instances repaired by the original or Agentic-Base reports. TrajSpec reports improve Pass@1 over the original reports by 45.53% with GPT-5-mini and 17.68% with MiniMax M2.5. They also outperform Agentic-Base reports under both LLM backbones and expand repair coverage while preserving almost all previously repaired instances.
Motivation. RQ1 evaluates TrajSpec reports using Mini-SWEAgent V2 [16] as the downstream repair agent. The observed gains may therefore depend on how Mini-SWE-Agent V2 uses the refined reports, rather than on whether the same reports are useful for other repair agents. RQ2 addresses this question by providing the same reports to other repository-level repair agents and measuring their repair performance. Approach. We reuse the GPT-5-mini-generated report variants evaluated in RQ1, including the original reports, AgenticBase reports, and TrajSpec reports, and provide them to Agentless [15] and AutoCodeRover [2]. These two repair agents differ from Mini-SWE-Agent V2 in how they organize repository navigation, localization, and patch generation. Running both agents on all 300 SWE-Bench Lite [6] instances for each report variant would require substantially greater computational resources. We therefore evaluate them on a stratified sample of 100 instances from SWE-Bench Lite, preserving the proportion of instances from each repository in the full 300-instance dataset. For each report variant, we run Agentless and AutoCodeRover independently using GPT5-mini (gpt-5-mini-2025-08-07) [41] as the underlying language model and report the Pass@1. Results. TrajSpec reports improve Pass@1 over the original reports by 73.17% with Agentless and 53.19% with AutoCodeRover. Table III reports the Pass@1 results for Agentless and AutoCodeRover. With Agentless, the original reports achieve 41.00% Pass@1, while Agentic-Base reports increase Pass@1 to 54.00%. TrajSpec reports further increase Pass@1 to 71.00%, corresponding to a 73.17% relative improvement over the original reports and a 31.48% relative improvement over Agentic-Base reports. With AutoCodeRover, the original reports achieve 47.00% Pass@1 and Agentic-Base reports achieve 52.00%. TrajSpec reports an increase in Pass@1 to 72.00%, corresponding to a 53.19% relative improvement over the original reports and a 38.46% relative improvement over
TABLE III: Pass@1 of Agentless and AutoCodeRover using original reports, Agentic-Base reports, and TrajSpec reports. The best result for each repair agent is highlighted in bold. Report Variant
Agentless
AutoCodeRover
Original Agentic-Base TrajSpec
41% 54% 71%
47% 52% 72%
Agentic-Base reports. These improvements appear across two repair agents with different designs. Agentless decomposes repair into localization, patch generation, and validation, while AutoCodeRover uses structure-aware repository search to guide patch generation. The consistent gains across these agents suggest that the benefit of trajectory-guided specification refinement is not tied to the workflow of a particular downstream repair agent, but extends to agents with different localization and patchgeneration strategies. On 100 stratified SWE-Bench Lite instances, TrajSpec reports improve Pass@1 over the original reports by 73.17% with Agentless and 53.19% with AutoCodeRover. They also outperform Agentic-Base reports under both downstream repair agents. RQ3: How do the repository-based review and hierarchical evidence representation of TrajSpec contribute to repair performance? Motivation. TrajSpec relies on two key components to produce repository-supported specifications: a hierarchical evidence representation and repository-based review. In this RQ, we ablate the hierarchical evidence representation and repository-based review to quantify their contributions to TrajSpec’s repair performance. Approach. We construct two ablated variants of TrajSpec, each removing one key component: 1) Without repository-based review: This variant omits the repository-based reviewer agent. The draft refined report is used directly as input to the downstream repair agent, without repository-based review or revision. 2) Without hierarchical evidence representation: This variant removes the hierarchical evidence representation. Therefore, it generates the refined report without organizing the extracted evidence into the high-level, mid-level, and low-level structure described in Section IV-B, while keeping all other components unchanged in TrajSpec. We conduct our ablation study on all 300 SWE-Bench Lite [6] instances. For TrajSpec and both ablated variants, we use GPT-5-mini (gpt-5-mini-2025-08-07) [41] for every LLM call involved in the corresponding refinement variant, including trajectory collection, evidence extraction, hierarchical evidence abstraction when present, draft report generation, and repository-based review when present. We then use Mini-SWE-Agent V2 [16] with GPT-5-mini to generate
TABLE IV: Ablation results on 300 SWE-Bench Lite instances using Mini-SWE-Agent V2 with GPT-5-mini. Results are reported as the number of resolved instances and Pass@1. Arrows indicate relative decrease compared with the full TrajSpec. Variant TrajSpec w/o Reviewer w/o Hierarchy
Resolved
Pass@1
179 144 143
59.67% 48.00% (↓19.55%) 47.67% (↓20.11%)
patches from the resulting reports and measure Pass@1 repair success. Results. Both repository-based review and the hierarchical evidence representation substantially contribute to repair performance. Table IV summarizes the ablation results. The full TrajSpec achieves a Pass@1 of 59.67%. Removing repository-based review reduces Pass@1 to 48.00%, corresponding to a 19.55% relative decrease. Removing the hierarchical evidence representation reduces Pass@1 to 47.67%, corresponding to a 20.11% relative decrease. Both ablations remain above the original-report performance reported in RQ1 (41.00%), indicating that repository exploration alone provides useful repair-relevant context. However, the substantial gap between the ablated variants and the full TrajSpec shows that organizing hierarchical evidence and reviewing the generated specification are both important contributors to the overall repair gains achieved by TrajSpec. Ablation results on 300 SWE-Bench Lite instances show that removing repository-based review reduces Pass@1 from 59.67% to 48.00% (↓19.55%), while removing the hierarchical evidence representation reduces Pass@1 to 47.67% (↓20.11%). Both components contribute substantially to the repair gains achieved by TrajSpec. RQ4: What are the costs of generating TrajSpec’s refined bug reports and using them for automated program repair? Motivation. To generate refined reports, TrajSpec explores the repository, organizes diagnostic evidence, generates a draft report, and applies repository-based review. These operations incur token and monetary costs. At the same time, the report provided to the repair agent may affect the cost of downstream repair. RQ4, therefore, evaluates both the cost of generating refined reports and the total cost of using those reports for automated program repair. Approach. We measure two cost sources for each report variant. First, we measure report-generation cost, which includes the tokens and estimated monetary cost needed to produce the Agentic-Base and TrajSpec reports. For generated report variants, this cost includes all pre-repair LLM calls, including trajectory collection, evidence extraction, hierarchical evidence abstraction, draft report generation, and repository-based review when applicable. The original report incurs no reportgeneration cost because it uses the benchmark bug reports
TABLE V: Average per-instance computational cost of report generation and downstream repair on 300 SWE-Bench Lite instances. Report-generation costs are estimated from token usage and model pricing, while repair token usage and costs are recorded from Mini-SWE-Agent V2 execution logs. The original variant uses the benchmark bug report directly and therefore incurs no report-generation cost. Model
Report Variant
Report Generation
Repair
Total
Input Tokens
Output Tokens
Cost
Input Tokens
Output Tokens
Cost
Input Tokens
Output Tokens
Cost
GPT-5-mini
Original Agentic-Base TrajSpec
– 85K 224K
– 5K 16K
$0.000 $0.031 $0.087
331K 242K 251K
6K 5K 5K
$0.027 $0.021 $0.023
331K 327K 475K
6K 10K 21K
$0.027 $0.052 $0.110
MiniMax M2.5
Original Agentic-Base TrajSpec
– 50K 194K
– 2K 5K
$0.000 $0.009 $0.034
1,435K 980K 1,089K
13K 13K 12K
$0.075 $0.056 $0.060
1,435K 1,030K 1,283K
13K 15K 17K
$0.075 $0.065 $0.094
directly. Second, we measure repair cost, which includes the tokens and monetary costs incurred by Mini-SWE-Agent V2 [16] during the repair process when given the corresponding report variant. For each variant, we report the reportgeneration cost, repair cost, and their sum as the total perinstance cost. All costs are reported as averages over the 300 SWE-Bench Lite [6] instances.
Including report generation and repair, TrajSpec costs $0.110 per instance with GPT-5-mini and $0.094 with MiniMax M2.5. Although higher than using the original reports directly, the absolute increases are only $0.083 and $0.019 per instance, while Pass@1 improves by 45.53% and 17.68% for GPT-5-mini and MiniMax M2.5, respectively. Moreover, once the refined report is generated, downstream repair becomes cheaper. VI. T HREATS TO VALIDITY
Results. TrajSpec reduces downstream repair cost and inputtoken usage. Table V reports the average per-instance costs of report generation, repair, and their combined total. With GPT-5-mini, TrajSpec reports reduce downstream repair cost from $0.027 for the original reports to $0.023, while reducing repair input tokens from 331K to 251K. With MiniMax M2.5, TrajSpec reports reduce downstream repair cost from $0.075 for the original reports to $0.060, while reducing repair input tokens from 1.435M to 1.089M. Thus, once the refined report is generated, TrajSpec reduces repair input-token usage by approximately 24% under both LLM backbones while also lowering the monetary cost of the downstream repair run.
TrajSpec achieves substantially higher repair success with a modest increase in absolute end-to-end cost. When report generation and repair are considered together, TrajSpec costs $0.110 per instance with GPT-5-mini and $0.094 with MiniMax M2.5. Although these totals are higher than those of the original and Agentic-Base variants, they remain at most $0.110 per instance. Compared with using the original reports, the additional cost is $0.083 per instance with GPT-5-mini and $0.019 with MiniMax M2.5. In return, as shown in RQ1 (Section V), TrajSpec reports improve Pass@1 by 45.53% over the original reports and 22.60% over Agentic-Base reports with GPT-5-mini. With MiniMax M2.5, TrajSpec reports improve Pass@1 by 17.68% over the original reports and 21.38% over Agentic-Base reports. Overall, the refined reports incur a small absolute monetary overhead while producing substantially stronger repair outcomes. Once generated, they also reduce downstream repair cost and input-token consumption.
Internal Validity. Our results depend on the correctness of trajectory collection, evidence abstraction, repository-based review, and downstream repair execution. Errors in repository checkout, tool execution, trajectory logging, or benchmark validation could affect the generated refined reports or measured Pass@1 outcomes. To mitigate this risk, we keep prompts, model settings, and refinement procedures fixed across instances. TrajSpec uses only the original bug report and pre-fix repository during refinement, discards any candidate patch produced during the trajectory-collection run, and does not access the developer patch, post-fix code, or benchmark outcome. Since trajectories are unverified, they may contain weakly supported claims or abandoned hypotheses. TrajSpec therefore treats trajectories only as candidate evidence and applies repository-based review before producing the final refined report. Although this prevents pipeline-level leakage, model-level memorization of public benchmark artifacts remains a possible threat in LLM-based studies. External Validity. Our evaluation uses SWE-Bench Lite [6], which consists of real-world GitHub issues from Python opensource projects. Although the design of TrajSpec is languageagnostic, our evaluation does not establish its effectiveness for other programming languages or benchmarks. The results may also depend on the downstream repair agents and LLMs used in the evaluation. We partially mitigate this threat by evaluating TrajSpec with Mini-SWE-Agent V2 [16], Agentless [15], and AutoCodeRover [2], and with two LLM models, GPT-5-mini (gpt-5-mini-2025-08-07) [41] and MiniMax M2.5 (minimax-m2.5) [42]. Further evaluation on additional benchmarks, ecosystems, and repair frameworks remains future work. Construct Validity. We measure the effectiveness of refined reports using Pass@1 under the SWE-Bench Lite oracle [6].
This metric matches our goal of improving downstream APR, since an instance is counted as resolved only when the generated patch passes both the benchmark’s fail-to-pass and pass-to-pass tests. However, Pass@1 measures end-to-end repair success rather than standalone properties of the refined report, such as readability, conciseness, or human-perceived diagnostic quality. Therefore, our conclusions focus on the utility of refined reports for automated repair rather than on all possible dimensions of report quality. VII. C ONCLUSION Bug reports serve as the primary task specifications for repository-level APR agents, but they often omit repairrelevant information needed to understand the failure, infer the intended behavior, and identify the implementation scope for repair. In this paper, we presented TrajSpec, a trajectory-guided approach for repository-supported bug report specification refinement. TrajSpec uses the trajectory produced by an unverified trajectory-collection run to recover specification evidence, organizes that evidence into a hierarchical representation, and applies repository-based review to produce a refined report for downstream repair. Our evaluation on all 300 SWE-Bench Lite instances shows that TrajSpec improves Pass@1 from 41.00% to 59.67% with GPT-5-mini and from 54.67% to 64.33% with MiniMax M2.5, using Mini-SWE-Agent V2 as the downstream repair agent. On a repository-stratified 100-instance subset, TrajSpec also improves Agentless from 41.00% to 71.00% and AutoCodeRover from 47.00% to 72.00%. These results show that trajectories can be reused beyond candidate patch generation: when abstracted, structured, and reviewed against the pre-fix repository, they provide actionable repository-supported evidence that improves the specifications guiding automated repair. R EFERENCES [1] J. Yang, C. E. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, “Swe-agent: Agentcomputer interfaces enable automated software engineering,” Advances in Neural Information Processing Systems, vol. 37, pp. 50 528–50 652, 2024. [2] Y. Zhang, H. Ruan, Z. Fan, and A. Roychoudhury, “Autocoderover: Autonomous program improvement,” in Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis. Association for Computing Machinery, 2024, p. 1592–1604. [3] I. Bouzenia, P. Devanbu, and M. Pradel, “Repairagent: An autonomous, llm-based agent for program repair,” in 2025 IEEE/ACM 47th International Conference on Software Engineering (ICSE). IEEE, 2025, pp. 2188– 2200. [4] Q. Zhang, C. Gao, Y. Han, Y. Shang, C. Fang, Z. Chen, and L. Xiao, “Sgagent: Suggestion-guided llm-based multi-agent framework for repository-level software repair,” ACM Transactions on Software Engineering and Methodology, 2026.
[5] H. Tamoyan, S. Narenthiran, E. Arakelyan, M. Mezini, and B. Ginsburg, “Sherloc: Structured diagnostic localization for code repair agents,” arXiv preprint arXiv:2606.24820, 2026. [6] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. Narasimhan, “Swe-bench: Can language models resolve real-world github issues?” in International Conference on Learning Representations, vol. 2024, 2024, pp. 54 107–54 157. [7] N. Bettenburg, S. Just, A. Schröter, C. Weiss, R. Premraj, and T. Zimmermann, “What makes a good bug report?” in Proceedings of the 16th ACM SIGSOFT International Symposium on Foundations of software engineering, 2008, pp. 308–318. [8] M. Soltani, F. Hermans, and T. Bäck, “The significance of bug report elements,” Empirical Software Engineering, vol. 25, no. 6, pp. 5255–5294, 2020. [9] A. R. Chen, T.-H. P. Chen, and S. Wang, “Demystifying the challenges and benefits of analyzing user-reported logs in bug reports,” Empirical Software Engineering, vol. 26, no. 1, pp. 1–30, 2021. [10] A. R. Chen, T.-H. Chen, and S. Wang, “Pathidea: Improving information retrieval-based bug localization by re-constructing execution paths using logs,” IEEE Transactions on Software Engineering, vol. 48, no. 8, pp. 2905–2919, 2021. [11] T. Hirsch and B. Hofer, “Root cause prediction based on bug reports,” in 2020 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW). IEEE, 2020, pp. 171–176. [12] M. Medeiros, U. Kulesza, R. Coelho, R. Bonifácio, C. Treude, and E. A. Barbosa, “The impact of bug localization based on crash report mining: A developers’ perspective,” in Proceedings of the 46th International Conference on Software Engineering: Software Engineering in Practice, 2024, pp. 13–24. [13] M. Suri, X. Li, M. Shojaie, S. Han, C.-C. Hsu, S. Garg, A. A. Deshmukh, and V. Kumar, “Codescout: Contextual problem statement enhancement for software agents,” in Findings of the Association for Computational Linguistics: ACL 2026, 2026, pp. 40 902–40 931. [14] S. Kuang, Z. Tian, K. Lin, C. Tao, S. Wang, H. Bai, L. Shang, and J. Chen, “Reagent: Requirement-driven llm agents for software issue resolution,” arXiv preprint arXiv:2604.06861, 2026. [15] C. S. Xia, Y. Deng, S. Dunn, and L. Zhang, “Demystifying llm-based software engineering agents,” vol. 2, no. FSE, 2025, pp. 801–824. [16] P. N. Group and Contributors, “mini-swe-agent v2: The minimal ai software engineering agent,” https://github. com/SWE-agent/mini-swe-agent, 2025, accessed: 202606-26. [17] Z. Yu, H. Zhang, Y. Zhao, H. Huang, M. Yao, K. Ding, and J. Zhao, “Orcaloca: An llm agent framework for software issue localization,” arXiv preprint arXiv:2502.00350, 2025.
[18] C. S. Xia, Z. Wang, Y. Yang, Y. Wei, and L. Zhang, “Live-swe-agent: Can software engineering agents selfevolve on the fly?” arXiv preprint arXiv:2511.13646, 2025. [19] X. Wang, B. Li, Y. Song, F. F. Xu, X. Tang, M. Zhuge, J. Pan, Y. Song, B. Li, J. Singh et al., “Openhands: An open platform for ai software developers as generalist agents,” in International Conference on Learning Representations, vol. 2025, 2025, pp. 65 882–65 919. [20] S. Rastkar, G. C. Murphy, and G. Murray, “Summarizing software artifacts: a case study of bug reports,” in Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering-Volume 1, 2010, pp. 505–514. [21] M. Nayrolles, A. Hamou-Lhadj, S. Tahar, and A. Larsson, “Jcharming: A bug reproduction approach using crash traces and directed model checking,” in 2015 IEEE 22nd International Conference on Software Analysis, Evolution, and Reengineering (SANER). IEEE, 2015, pp. 101–110. [22] Y. Dang, R. Wu, H. Zhang, D. Zhang, and P. Nobel, “Rebucket: A method for clustering duplicate crash reports based on call stack similarity,” in 2012 34th International Conference on Software Engineering (ICSE). IEEE, 2012, pp. 1084–1093. [23] J. Acharya and G. Ginde, “Can we enhance bug report quality using llms?: An empirical study of llm-based bug report generation,” arXiv preprint arXiv:2504.18804, 2025. [24] A. Al Hasan, S. Saha, M. M. Imran, and T. S. Zaman, “Llput: Investigating large language models for bug report-based input generation,” in Proceedings of the 33rd ACM International Conference on the Foundations of Software Engineering, 2025, pp. 1652–1659. [25] S. Fahim, M. N. Rafi, Z. Ma, D. J. Kim et al., “Crash report enhancement with large language models: An empirical study,” arXiv preprint arXiv:2509.13535, 2025. [26] B. Yang, J. Ren, S. Jin, Y. Liu, F. Liu, B. Le, and H. Tian, “Enhancing repository-level software repair via repository-aware knowledge graphs,” arXiv preprint arXiv:2503.21710, 2025. [27] Z. Pan, C. Li, W. Zhong, Y. Feng, B. Luo, and V. Ng, “Reporepair: Leveraging code documentation for repository-level automated program repair,” arXiv preprint arXiv:2603.01048, 2026. [28] F. Mu, J. Wang, L. Shi, S. Wang, S. Li, and Q. Wang, “Experepair: Dual-memory enhanced llmbased repository-level program repair,” arXiv preprint arXiv:2506.10484, 2025. [29] C. Li, Y. Xu, Z. Wang, S. H. Tan et al., “Outcomeconditioned reasoning distillation for resolving software
issues,” arXiv preprint arXiv:2601.23257, 2026. [30] J. Zhu, J. Wu, M. Hu, S. Zhu, J. Pan, W. Shen, Y. Yang, F. Liu, J. Hao, Y. Jin et al., “Swe context bench: A benchmark for context learning in coding,” arXiv preprint arXiv:2602.08316, 2026. [31] I. Bouzenia and M. Pradel, “Understanding software engineering agents: A study of thought-action-result trajectories,” in 2025 40th IEEE/ACM International Conference on Automated Software Engineering (ASE), 2025, p. 2846–2857. [32] T. Zhu, L. C. Cordeiro, M. A. Mustafa, and Y. Sun, “Specification vibing for automated program repair,” arXiv preprint arXiv:2602.08263, 2026. [33] Z. Huang, L. Xu, C. Liu, W. Sun, X. Zhang, Y. Lei, M. Yan, and H. Zhang, “Dynafix: Iterative automated program repair driven by execution-level dynamic information,” arXiv preprint arXiv:2512.24635, 2025. [34] E. F. Akyol, M. Dedeler, and E. Tüzün, “Improbr: Bug report improver using llms,” arXiv preprint arXiv:2604.26142, 2026. [35] Z. Pei, H.-L. Zhen, S. Kai, S. J. Pan, Y. Wang, M. Yuan, and B. Yu, “Scope: Prompt evolution for enhancing agent effectiveness,” arXiv preprint arXiv:2512.15374, 2025. [36] Y. Lyu, J. Shi, H. J. Kang, R. Widyasari, J. He, Y. Niu, C. Yang, J. Chen, Z. Yang, J. Lawall et al., “Agentszz: Teaching the llm agent to play detective with buginducing commits,” arXiv preprint arXiv:2604.02665, 2026. [37] P. Yang, W. Chen, T. Yang, P. Feng, J. Xing, W. Guo, Y. Yao, Y. Han, H. Li, X. Wang et al., “Twinrouterbench: Fast static and live dynamic evaluation for realistic agentic llm routing,” arXiv preprint arXiv:2605.18859, 2026. [38] A. J. Li, H. Huang, Y. Park, Y. Ma, W.-L. Chiang, L. Chen, C.-J. Hsieh, B. Yu, and I. Stoica, “Dualeval: Joint model-item calibration for unified llm evaluation,” arXiv preprint arXiv:2606.26429, 2026. [39] S. Joshi, P. Dixit, A. Chowdhury, A. Shrivastava, J. E. Gonzalez, I. Stoica, K. K. Agrawal, and A. Desai, “Inference time context sparsity: Illusion or opportunity?” arXiv preprint arXiv:2605.24168, 2026. [40] Y. Zhang, J. Fan, M. Fan, S. Zhang, and X. Du, “Codabench: Can code agents handle data-intensive tasks?” arXiv preprint arXiv:2606.15300, 2026. [41] OpenAI, “Gpt-5 mini model,” https://developers.openai. com/api/docs/models/gpt-5-mini, 2025, accessed: 202606-26. [42] MiniMax, “Minimax m2.5: Built for real-world productivity,” https://www.minimax.io/news/minimax-m25, 2026, accessed: 2026-06-26.