versioned storage

This work addresses the challenge of determining whether a local recovery point is semantically valid when structured tool-using agents fail mid-execution, particularly in scenarios where downstream components have already committed to outputs from upstream stages. The paper introduces DART, a runtime system that formalizes the notion of “semantic recoverability” for the first time. DART enables safe and efficient partial recovery by identifying failure instances, verifying semantic boundaries, aligning checkpoints, and selecting legitimate recovery points under dependency and effect constraints. Its modular architecture incorporates explicit acceptability checks to prevent invalidation of already-committed downstream work. Empirical evaluation across three LLM-driven tasks and the LangGraph framework demonstrates that DART successfully recovers all commitment-sensitive cases where baseline methods fail, with no unsafe rollbacks detected in a five-domain safety audit.

Modern data storage systems suffer from latent cross-layer faults due to tight hardware–software coupling across multiple abstraction layers, often leading to silent data corruption or unrecoverable data loss. To address this, we propose the first cross-layer fault-tolerance analysis framework targeting heterogeneous storage stacks—including SSDs, persistent memory, local file systems, and distributed storage. Our approach combines architectural modeling of the full stack, systematic injection of representative defects, and precise tracking of fault propagation across hardware–firmware–software boundaries to expose error propagation paths and consistency violation mechanisms. Through empirical evaluation across widely deployed systems, we identify critical vulnerabilities impacting data integrity and quantify coverage gaps in existing fault-tolerance techniques. The framework provides a scalable, principled methodology for analyzing cross-layer resilience and establishes concrete, actionable directions for designing next-generation highly reliable storage systems.

Non-reproducibility in Java software builds severely undermines supply-chain security and artifact integrity verification. To address this, we systematically identify and classify six categories of non-deterministic root causes, establishing the first large-scale taxonomy of reproducibility failures in Java. We propose a two-tier normalization framework: artifact-level standardization via OSS-Rebuild and bytecode-level canonicalization via jNorm. Building upon these, we design Chains-Rebuild—a fully automated, end-to-end reproducibility-enhancement toolchain—and release the first large-scale dataset of non-reproducible Java builds. Experimental evaluation on 12,283 non-reproducible Java artifacts demonstrates that our approach increases the reproducibility rate from 9.48% to 26.89%. This work establishes a verifiable, reproducible software delivery paradigm for the Java ecosystem.

This study addresses the longstanding fragmentation in software artifact traceability research, characterized by incomplete linkages, ambiguous techniques, and disconnected application contexts. Through a systematic literature review, it constructs the first comprehensive traceability landscape encompassing 22 artifact types and 23 relationship kinds, and introduces a technology decision map, a standardized evaluation benchmark, and a role-oriented dynamic path alignment framework. The work uncovers critical challenges: a pervasive code-centric bias, a reproducibility crisis stemming from only 37% of studies releasing open-source artifacts, and a significant adoption gap with 95% of proposed tools never deployed in industry. In response, it offers targeted strategies to bridge these gaps, establishing a unified knowledge foundation for future research and practical implementation in traceability.

This work addresses two critical limitations of Git-based data versioning tools (e.g., DataLad) in HPC environments: incompatibility with the Slurm batch scheduler and poor I/O efficiency on parallel file systems (e.g., Lustre, GPFS). We propose the first lightweight, non-intrusive framework that deeply integrates DataLad with Slurm. Our approach extends Slurm’s job encapsulation mechanism and introduces automated, fine-grained metadata capture at the job level, thereby ensuring end-to-end reproducibility. Furthermore, we optimize versioning operations—such as dataset checkout and commit—by adapting their I/O paths for parallel file systems. Evaluation on a production supercomputing cluster demonstrates a 92% reduction in metadata capture overhead and a 3.8× speedup in large-dataset version switching. These improvements significantly broaden the applicability of data version control to production-scale HPC batch workflows.

This work addresses critical challenges in persistent memory management for large language model agents, including error propagation, unreliable updates, and lack of fault recovery. The paper introduces MemTxn, the first governance layer that enforces transactional boundaries over agent memory. MemTxn ensures reliable memory management through source-validated updates, temporal version resolution, and snapshot-log-driven state recovery, enabling consistent declarative state reconstruction without relying on physical write sets. The system employs an Ordered PatchTest to validate writes, a Temporal Resolver to handle conflicts, and supports full fault recovery. Experimental results demonstrate that MemTxn accepts all valid updates and rejects all hard negative samples in audit tests, achieves exact state recovery on LongMemEval-S and LoCoMo benchmarks, and significantly outperforms the Dense baseline by 17.06–24.07 F1 points on the FactConsolidation task in MemoryAgentBench.

This study addresses the temporal stability of reproducible builds in the F-Droid ecosystem, where open-source Android applications are initially reproducible but may degrade over time due to ecosystem evolution. Conducting the first large-scale empirical analysis, the authors evaluate 18,904 historical app versions through automated rebuilding, dependency-missing diagnostics, and bit-for-bit output comparison. Their findings reveal that 83% of versions can be successfully rebuilt, with 94% of those achieving bitwise identical outputs. However, 76% of rebuild failures stem from missing dependencies, demonstrating a significant decay in reproducibility over time. These results underscore the critical need for robust, long-term mechanisms to sustain build reproducibility in evolving software ecosystems.

This work addresses the challenge that flat patches generated by code agents lack structured commit histories, hindering code review, rollback, and maintenance. It formalizes retrospective commit history reconstruction as a code block segmentation task under replay constraints, introduces a benchmark dataset comprising 800 real sequential commits, and proposes multidimensional evaluation metrics—PPAR, ARI, and TCR. The method leverages large language models (e.g., GPT-5.4, GLM-5) augmented with code roles and dependency information for clustering, incorporating Dependency-Aware Clustering Evidence (DACE) to improve grouping accuracy and validating executability through replay. The best-performing model achieves an ARI of 0.46, significantly outperforming baselines; DACE further boosts low-scoring systems by 0.05–0.08 ARI, revealing that reconstructing real-world commit histories is substantially more difficult than synthetic scenarios.

This work addresses the challenge of repository breakage caused by dependency and runtime evolution, which often incurs high repair costs due to insufficient maintenance. We present the first systematic evaluation of large language model (LLM) agents’ capability to automatically diagnose and fix full-repository compatibility issues—restoring historical test-passing states—given only the original code and a modern failing environment. Our benchmark comprises 193 Python and 122 Java repositories, augmented with source-exclusive auditing, runtime constraints, and real-world validation protocols. Leveraging techniques such as test re-execution, test masking, and cross-file coordinated analysis, our experiments show that Kimo repairs 41.5% of repositories without modifying test files, and a multi-agent ensemble achieves 62.7%. Among the repaired Python repositories, 22 are validated in real environments, with 12 confirmed by targeted bug detection.

This work addresses the limitations of existing reproducibility assessment methods, which rely on manual annotations and thus lack scalability and authentic supervision signals reflecting real-world reproduction challenges. The authors propose the first scalable evaluation framework that leverages GitHub user-submitted issues as natural supervision, enabling large-scale assessment of large language model (LLM) agents’ ability to identify paper-to-code reproducibility issues without human annotation. By integrating language understanding with code context analysis, the approach enables non-execution-based detection of reproducibility barriers. Experimental results demonstrate that the best-performing LLM agent identifies at least one semantically relevant reproducibility issue—aligned with those reported by humans—in approximately 90% of the evaluated papers, exhibiting strong performance in both failure detection and semantic localization.