## Phase 127: Kalika Materials Code Interoperability & Databases — VASP, Quantum ESPRESSO, ABINIT, LAMMPS, Phonopy, WANNIER90, ASE, pymatgen Compatibility & Materials Database APIs

Comprehensive interfaces to all major computational materials science codes and
databases. This phase is critical for researcher adoption — users need to
integrate Kalika with their existing DFT, MD, and post-processing workflows.
Targets feature parity with ASE, pymatgen, atomate/atomate2, FireWorks/jobflow,
and custodian. Covers input generation, output parsing, error handling, database
APIs, and workflow orchestration for VASP, Quantum ESPRESSO, ABINIT, FHI-aims,
LAMMPS, GROMACS, Phonopy, WANNIER90, LOBSTER, BoltzTraP2, and 10+ additional
codes. TypeScript (~70%) for orchestration and I/O logic, Rust (~10%) for
performance-critical parsing (large trajectory files, charge density grids),
Python (~20%) for bridges to the ASE/pymatgen/AiiDA ecosystems.

---

### 127.1 Scaffolding & Core Types (`@kalika/code-interfaces`)

#### 127.1.1 Library Scaffolding

- [x] **127.1.1.1** Create directory structure for
      `libs/kalika/code-interfaces/` with `package.json`, `project.json`,
      `tsconfig.json`, and `src/index.ts` barrel export — register path mapping
      in `tsconfig.base.json`
- [x] **127.1.1.2** Create directory structure for `libs/kalika/vasp-io/` with
      `package.json`, `project.json`, `tsconfig.json`, and `src/index.ts` — add
      path mapping
- [x] **127.1.1.3** Create directory structure for `libs/kalika/qe-io/` with
      `package.json`, `project.json`, `tsconfig.json`, and `src/index.ts` — add
      path mapping
- [x] **127.1.1.4** Create directory structure for `libs/kalika/lammps-io/` with
      `package.json`, `project.json`, `tsconfig.json`, and `src/index.ts` — add
      path mapping
- [x] **127.1.1.5** Create directory structure for
      `libs/kalika/materials-databases/` with `package.json`, `project.json`,
      `tsconfig.json`, and `src/index.ts` — add path mapping
- [x] **127.1.1.6** Create directory structure for `libs/kalika/workflows/` with
      `package.json`, `project.json`, `tsconfig.json`, and `src/index.ts` — add
      path mapping
- [x] **127.1.1.7** Create directory structures for ancillary interface
      libraries: `libs/kalika/abinit-io/`, `libs/kalika/fhi-aims-io/`,
      `libs/kalika/phonopy-io/`, `libs/kalika/wannier90-io/`,
      `libs/kalika/lobster-io/`, `libs/kalika/boltztrap-io/`,
      `libs/kalika/gromacs-io/` — each with `package.json`, `project.json`,
      `tsconfig.json`, `src/index.ts`, and path mappings

#### 127.1.2 Core Type Definitions

- [x] **127.1.2.1** Implement `CalculationInput` type hierarchy: base type with
      `code: CodeName`, `version?: string`, `structure: KalikaStructure`,
      `parameters: Record<string, unknown>`, `resources: ComputeResources`
      (nprocs, memory, walltime, queue), `workDir: string`,
      `inputFiles:     Map<string, string>` — plus code-specific subtypes
      `VaspInput`, `QeInput`, `AbinitInput`, `LammpsInput` each with typed
      parameter sets
- [x] **127.1.2.2** Implement `CalculationOutput` type hierarchy: base type with
      `code: CodeName`, `status: JobStatus`, `walltime: number`,
      `exitCode:     number`, `energy?: number`, `forces?: Float64Array[]`,
      `stress?:     Float64Array`, `structure?: KalikaStructure`,
      `rawFiles: Map<string,     Buffer>`, `parseErrors: ParseError[]` — plus
      code-specific subtypes with typed parsed results (eigenvalues, DOS, band
      structure, etc.)
- [x] **127.1.2.3** Implement `CodeInterface` abstract class:
      `generateInputs(calc:     CalculationInput): Map<string, string | Buffer>`,
      `parseOutputs(files: Map<string, Buffer>): CalculationOutput`,
      `validateInputs(calc: CalculationInput): ValidationResult[]`,
      `detectErrors(output: CalculationOutput): CodeError[]`,
      `suggestFixes(errors: CodeError[]): Fix[]` — the contract every code
      adapter must implement
- [x] **127.1.2.4** Implement `WorkflowStep` type: `id: string`, `name: string`,
      `code: CodeName`, `inputTemplate: CalculationInput`,
      `dependencies:     string[]` (step IDs),
      `outputMapping: Map<string, string>` (how outputs from dependencies map to
      this step's inputs),
      `condition?:     (outputs: Map<string, CalculationOutput>) => boolean`
      (conditional execution), `retryPolicy: RetryPolicy`
- [x] **127.1.2.5** Implement `WorkflowDAG` class: topological sort of
      `WorkflowStep` nodes, cycle detection, dependency resolution, `addStep()`,
      `removeStep()`, `connect(from, to, mapping)`,
      `validate(): ValidationResult[]`, `getExecutionOrder(): string[][]`
      (returns layers of parallelizable steps), serialization to/from JSON
- [x] **127.1.2.6** Implement `JobStatus` enum and state machine:
      `CREATED → SUBMITTED → QUEUED → RUNNING → COMPLETED | FAILED | CANCELLED`,
      with transition validation, timestamp tracking for each state change, and
      `JobStatusHistory` recording all transitions

#### 127.1.3 Structure Conversion Utilities

- [x] **127.1.3.1** Implement `KalikaStructure` canonical type: lattice vectors
      (3x3 matrix), species list, fractional coordinates, Cartesian coordinates,
      site properties (magnetic moment, charge, selective dynamics flags),
      `toCartesian()`, `toFractional()`, `getVolume()`, `getLatticeParameters()`
      (a, b, c, alpha, beta, gamma), `getReciprocalLattice()`,
      `getSuperCell(nx,     ny, nz)`, `applySymmetry(spaceGroup)`
- [x] **127.1.3.2** Implement CIF ↔ KalikaStructure converter: parse CIF files
      (IUCr CIF 1.1 and 2.0 format) including symmetry operations, site
      occupancies, anisotropic displacement parameters — and write CIF from
      KalikaStructure with space group, Wyckoff positions, and all standard CIF
      data blocks
- [x] **127.1.3.3** Implement POSCAR/CONTCAR ↔ KalikaStructure converter:
      read/write VASP 5.x format (species line, direct/Cartesian, selective
      dynamics, velocities) — exact formatting to match VASP expectations
- [x] **127.1.3.4** Implement XYZ/extXYZ ↔ KalikaStructure converter: standard
      XYZ and extended XYZ (with lattice, properties columns) — supporting
      multi-frame trajectories
- [x] **127.1.3.5** Implement PDB ↔ KalikaStructure converter: Protein Data Bank
      format for biomolecular structures — ATOM/HETATM records, CRYST1 (unit
      cell), CONECT (bonds)

#### 127.1.4 Unit System & Physical Constants

- [x] **127.1.4.1** Implement unit conversion registry: energy (eV, Ry, Ha, J,
      kcal/mol, kJ/mol, cm⁻¹, K, meV), length (Å, Bohr, nm, pm), force (eV/Å,
      Ha/Bohr, N), pressure (GPa, kbar, eV/Å³, Ha/Bohr³, Pa), time (fs, ps, au),
      mass (amu, kg, electron mass) — with composable unit arithmetic:
      `convert(value, 'eV/Å²', 'Ha/Bohr²')`
- [x] **127.1.4.2** Implement physical constants module: CODATA 2018 values for
      Bohr radius, Hartree energy, Rydberg constant, electron mass, Boltzmann
      constant, Planck constant, speed of light, fine structure constant,
      Avogadro number — all with uncertainties, and derived constants (eV_to_Ha,
      Bohr_to_Ang, etc.)

---

### 127.2 VASP Interface (`@kalika/vasp-io`)

#### 127.2.1 INCAR Generation

- [x] **127.2.1.1** Implement INCAR writer: serialize a typed `IncarParams`
      object to VASP INCAR format — proper formatting of scalars, arrays
      (MAGMOM), booleans (.TRUE./.FALSE.), string values, comment lines, tag
      ordering by category (general → electronic → ionic → output)
- [x] **127.2.1.2** Implement INCAR tag validation engine: validate all major
      tags against allowed values (ALGO: Normal/Fast/VeryFast/All/Damped/...,
      PREC: Accurate/Normal/Low/..., ISPIN: 1/2, LREAL: Auto/.TRUE./.FALSE.,
      ISMEAR: -5/-4/-1/0/1/2/..., IBRION: -1/0/1/2/3/5/6/7/8/44), range checks
      (ENCUT > 0, EDIFF > 0, SIGMA > 0, NSW >= 0), mutual exclusion checks
      (IBRION with NSW=0 is static), and dependency checks (LORBIT requires
      appropriate RWIGS or PAW)
- [x] **127.2.1.3** Implement INCAR tag database: comprehensive metadata for
      every supported VASP tag — name, type (int/float/bool/string/array),
      default value, allowed values/range, description, VASP version introduced,
      dependencies on other tags, category (electronic/ionic/output/symmetry/
      parallel/hybrid/GW/response) — at least 150 tags covering all VASP
      functionality
- [x] **127.2.1.4** Implement INCAR preset: `static` — IBRION=-1, NSW=0,
      ISMEAR=-5 (tetrahedron with Blöchl corrections for insulators) or
      ISMEAR=1/SIGMA=0.2 (metals), LREAL=Auto, PREC=Accurate, EDIFF=1e-6,
      LORBIT=11, LWAVE=.FALSE., LCHARG=.TRUE.
- [x] **127.2.1.5** Implement INCAR preset: `relaxation` — IBRION=2 (CG), ISIF=3
      (full cell+ions), NSW=100, EDIFF=1e-6, EDIFFG=-0.02 (force convergence),
      LREAL=Auto, PREC=Accurate, ISMEAR=1/SIGMA=0.2 (metals) or ISMEAR=0
      (insulators), LWAVE=.FALSE., LCHARG=.FALSE.
- [x] **127.2.1.6** Implement INCAR preset: `band_structure` —
      non-self-consistent calculation: ICHARG=11, ISMEAR=0/SIGMA=0.05,
      LORBIT=11, LWAVE=.FALSE., LCHARG=.FALSE., NEDOS=2001 — designed to be
      chained after a static run using the CHGCAR
- [x] **127.2.1.7** Implement INCAR preset: `dos` — ISMEAR=-5 (tetrahedron),
      NEDOS=3001, LORBIT=11 (projected DOS), EMIN/EMAX auto-set from band edges,
      ICHARG=11 (non-SCF from CHGCAR)
- [x] **127.2.1.8** Implement INCAR preset: `dielectric` — LEPSILON=.TRUE. (DFPT
      dielectric), IBRION=8 (DFPT), EDIFF=1e-8, LREAL=.FALSE., PREC=Accurate,
      plus variant for LOPTICS=.TRUE. (frequency-dependent dielectric from RPA)
- [x] **127.2.1.9** Implement INCAR preset: `neb` — IBRION=3 (damped MD for
      NEB), POTIM=0, ICHAIN=0, IMAGES=N (configurable), SPRING=-5, LCLIMB=.TRUE.
      (CI-NEB), EDIFF=1e-5, NSW=200
- [x] **127.2.1.10** Implement INCAR preset: `hybrid` — LHFCALC=.TRUE.,
      AEXX=0.25 (HSE06), HFSCREEN=0.2, ALGO=All (or Damped), TIME=0.4,
      PRECFOCK=Fast, NKRED if applicable — with variant for PBE0 (AEXX=0.25,
      HFSCREEN=0)
- [x] **127.2.1.11** Implement INCAR preset: `gw` — ALGO=GW, NOMEGA=100,
      NBANDS=large, ENCUTGW=auto, LSPECTRAL=.TRUE., plus variants for G0W0, GW0,
      scGW, and BSE (ALGO=BSE, NBANDSO/NBANDSV)
- [x] **127.2.1.12** Implement INCAR preset: `phonon_finite_diff` — IBRION=5
      (finite differences) or IBRION=6 (central differences), NFREE=2,
      EDIFF=1e-8, PREC=Accurate, LREAL=.FALSE., ADDGRID=.TRUE., ISYM=0
- [x] **127.2.1.13** Implement INCAR preset: `elastic` — IBRION=6, ISIF=3,
      NFREE=4, EDIFF=1e-8, PREC=Accurate, LREAL=.FALSE.
- [x] **127.2.1.14** Implement INCAR preset: `nmr` — LNMR_SYM_RED=.TRUE.,
      NSLPLINE=.TRUE., LCHIMAG=.TRUE., DQ=0.001, ICHIBARE=1-3, EDIFF=1e-8,
      LREAL=.FALSE.
- [x] **127.2.1.15** Implement INCAR preset: `aimd` — IBRION=0, ISIF=2 (NVT) or
      ISIF=3 (NPT), SMASS=0 (NVT via Nosé-Hoover) or SMASS=-1 (NVE), TEBEG/TEEND
      (temperatures), POTIM=1.0 (1 fs timestep), NSW=10000, PREC=Normal,
      ALGO=VeryFast, LREAL=Auto, LWAVE=.FALSE.
- [x] **127.2.1.16** Implement INCAR preset: `soc` — LSORBIT=.TRUE.,
      LNONCOLLINEAR=.TRUE., SAXIS specification, NBANDS typically doubled,
      GGA_COMPAT=.FALSE., LORBMOM=.TRUE.

#### 127.2.2 POSCAR & KPOINTS Generation

- [x] **127.2.2.1** Implement POSCAR writer: write VASP 5+ POSCAR from
      KalikaStructure — comment line, scaling factor, lattice vectors (16-digit
      precision), element symbols line, atom counts line, Selective dynamics
      (optional T/F flags), Direct/Cartesian toggle, fractional/Cartesian
      coordinates (16-digit precision), optional velocities block
- [x] **127.2.2.2** Implement POSCAR reader: parse VASP 5+ POSCAR/CONTCAR —
      handle scaling factor (including negative = volume), lattice vectors,
      species (VASP 5 element line), counts, selective dynamics flags,
      direct/Cartesian coordinates, velocities — return KalikaStructure
- [x] **127.2.2.3** Implement KPOINTS writer: automatic Monkhorst-Pack mesh
      (subdivisions + shift), automatic Gamma-centered mesh, and explicit
      k-point list mode — with auto-generation of k-mesh density from target
      k-point density (e.g., 50 k-points/Å⁻¹) and lattice parameters
- [x] **127.2.2.4** Implement KPOINTS line-mode writer: generate k-point path
      for band structure calculations — input: list of high-symmetry points (Γ,
      X, M, K, L, W, U, etc.) with labels and coordinates, number of points per
      segment; include automatic high-symmetry path detection from space group
      (using Setyawan-Curtarolo conventions)
- [x] **127.2.2.5** Implement high-symmetry k-path database: Brillouin zone
      high-symmetry points and standard paths for all 14 Bravais lattices (cF,
      cI, cP, tI, tP, oF, oI, oC, oP, hR, hP, mC, mP, aP) following
      Setyawan-Curtarolo (Comp. Mat. Sci. 49, 2010) conventions

#### 127.2.3 POTCAR Management

- [x] **127.2.3.1** Implement POTCAR library manager: configure path to local
      VASP POTCAR library (e.g., `$VASP_PP_DIR/`), scan for available
      functionals (PBE, PBE_52, PBE_54, LDA, PW91), list available potentials
      per element per functional, and concatenate POTCARs in the correct element
      order
- [x] **127.2.3.2** Implement recommended POTCAR selection: maintain a mapping
      of recommended PAW potentials per element (e.g., Li_sv, Na_pv, Ca_sv,
      Ti_pv, etc.) following pymatgen/Materials Project conventions — with
      fallbacks when recommended potential is unavailable
- [x] **127.2.3.3** Implement POTCAR validation: verify POTCAR integrity via
      checksum (SHA-256 or TITEL hash), ensure functional consistency (all
      potentials from same functional family), verify element order matches
      POSCAR, extract ENMAX values for automatic ENCUT determination (ENCUT =
      max(ENMAX) × 1.3)

#### 127.2.4 Output Parsing

- [x] **127.2.4.1** Implement OUTCAR parser: extract total energy (E0, energy
      without entropy, energy(sigma→0)), ionic forces (eV/Å), stress tensor
      (kbar), magnetization (per atom and total), timing breakdown, number of
      SCF iterations per ionic step, convergence history (energy, force, stress
      per step), warnings and errors
- [x] **127.2.4.2** Implement OUTCAR advanced property parser: Born effective
      charges (LEPSILON), macroscopic dielectric tensor (ionic + electronic
      contributions), elastic tensor C_ij (6×6), piezoelectric tensor e_ij, NMR
      chemical shielding tensors (σ_iso, σ_aniso, η), electric field gradients
      (V_zz, η), internal strain tensor
- [x] **127.2.4.3** Implement vasprun.xml parser: full XML parsing of VASP's
      structured output — extract: calculation parameters (INCAR as parsed),
      k-points, basis set info, initial/final structure, electronic structure
      (eigenvalues at each k-point and band, occupations), DOS (total +
      projected onto atoms/orbitals), forces, stress, energy per ionic step,
      dielectric function (real + imaginary parts vs. energy), born charges,
      timing — handle both collinear and non-collinear spin
- [x] **127.2.4.4** Implement DOSCAR parser: read total DOS (energy, DOS-up,
      DOS-down, integrated-DOS-up, integrated-DOS-down) and projected DOS (per
      atom, per orbital: s, p_y, p_z, p_x, d_xy, d_yz, d_z2, d_xz, d_x2-y2, and
      f orbitals if LORBIT=11) — return structured `DensityOfStates` object with
      energy grid, total, and projected components
- [x] **127.2.4.5** Implement EIGENVAL parser: read k-point coordinates,
      weights, and eigenvalues (per k-point, per band, per spin) — return
      `BandStructure` object with k-path, eigenvalues, Fermi energy, band gap
      detection (direct/indirect, VBM/CBM k-points)
- [x] **127.2.4.6** Implement PROCAR parser: read projected band structure —
      orbital weights (s, p, d, f decomposition) and atom decomposition at each
      k-point and band — for fat band and orbital-character analysis
- [x] **127.2.4.7** Implement CHGCAR/AECCAR reader: parse charge density on FFT
      grid — header (structure, grid dimensions), volumetric data (spin-up,
      spin-down for spin-polarized), augmentation charges — support CHGCAR,
      AECCAR0 (core), AECCAR2 (valence) for Bader analysis preparation
- [x] **127.2.4.8** Implement LOCPOT parser: read local potential on FFT grid —
      same format as CHGCAR but containing the electrostatic potential — for
      work function calculations (vacuum level extraction) and dipole
      corrections
- [x] **127.2.4.9** Implement WAVECAR reader (Rust + WASM): parse VASP WAVECAR
      binary format — extract header (ISPIN, NKPTS, NBANDS, ENCUT, lattice),
      plane-wave coefficients for each k-point and band — for Wannier90 input
      (.amn/.mmn computation) and wavefunction visualization.
      Performance-critical: use Rust for binary parsing of potentially multi-GB
      files
- [x] **127.2.4.10** Implement XDATCAR parser: read MD trajectory — sequence of
      structures at each ionic step in direct coordinates — return array of
      KalikaStructure with step indices
- [x] **127.2.4.11** Implement OSZICAR parser: read SCF convergence per ionic
      step — electronic iteration energies (dE, mag), ionic step energies and
      forces — for real-time convergence monitoring
- [x] **127.2.4.12** Implement ELFCAR parser: read electron localization
      function on FFT grid — same volumetric format as CHGCAR but values in
      [0,1] range — for chemical bonding analysis
- [x] **127.2.4.13** Implement IBZKPT parser: read irreducible k-points with
      weights after symmetry reduction — for verifying k-point meshes and
      symmetry-related debugging
- [x] **127.2.4.14** Implement ML_LOGFILE parser: parse VASP 6.3+ ML force field
      training log — extract training errors (energy, force, stress RMSE),
      Bayesian error estimates, ab initio vs. ML calls, training set size growth
      — for monitoring on-the-fly ML potential quality
- [x] **127.2.4.15** Implement vaspout.h5 reader: parse VASP 6.4+ HDF5 output
      format using an HDF5 reading library — extract all quantities (energies,
      forces, eigenvalues, DOS, charge density) from the structured HDF5
      hierarchy — the future-proof VASP output format

#### 127.2.5 Error Handling & Custodian-Matching Fixes

- [x] **127.2.5.1** Implement VASP error detector: scan OUTCAR and stdout for
      known error signatures — ZBRENT (bracketing failure in line minimization),
      EDDDAV (sub-space rotation error), ZPOTRF (Cholesky decomposition
      failure), SGRCON (symmetry error), PRICEL (primitive cell issue), BRMIX
      (Kerker mixing failure), DENTET (tetrahedron integration with too few
      k-points), RHOSYG (charge density symmetrization error), POSMAP (atom
      mapping error), TOO_FEW_BANDS, EDDRMM (RMM-DIIS not converging)
- [x] **127.2.5.2** Implement automatic fix suggestions matching custodian
      VaspErrorHandler: ZBRENT → reduce POTIM by 50%, EDDDAV → switch ALGO to
      All, ZPOTRF → reduce POTIM or switch to CG (IBRION=2), BRMIX → set
      IMIX=1/AMIX=0.1/BMIX=0.001, DENTET → switch to ISMEAR=0, TOO_FEW_BANDS →
      increase NBANDS by 25%, EDDRMM → switch ALGO to Normal, PRICEL → set
      SYMPREC=1e-8
- [x] **127.2.5.3** Implement SCF convergence monitor: track energy difference
      per electronic step, detect oscillation (sign alternation in dE), detect
      divergence (|dE| increasing), detect slow convergence (|dE| decreasing too
      slowly) — suggest ALGO/AMIX/AMIN/BMIX adjustments
- [x] **127.2.5.4** Implement ionic convergence monitor: track max force, stress
      components, energy per ionic step — detect: not converging (forces
      increasing), oscillating, converged-but-not-global-minimum (energy plateau
      with large forces) — suggest IBRION/POTIM adjustments
- [x] **127.2.5.5** Implement VASP version compatibility layer: detect VASP
      version from OUTCAR/vasprun.xml header, apply version-specific tag aliases
      and defaults (e.g., ML_LMLFF in 6.3+, LHARTREE in 6.4+), warn about
      deprecated tags, select appropriate output parser variant

---

### 127.3 Quantum ESPRESSO Interface (`@kalika/qe-io`)

#### 127.3.1 pw.x Input Generation

- [x] **127.3.1.1** Implement QE input file writer: generate pw.x input from
      typed `QeInput` object — format Fortran namelist blocks (&CONTROL,
      &SYSTEM, &ELECTRONS, &IONS, &CELL) with proper quoting and comma
      separation, followed by card blocks (ATOMIC_SPECIES, ATOMIC_POSITIONS,
      K_POINTS, CELL_PARAMETERS, CONSTRAINTS, OCCUPATIONS, ATOMIC_FORCES)
- [x] **127.3.1.2** Implement &CONTROL block generation: `calculation` type
      (scf/relax/vc-relax/md/vc-md), `prefix`, `outdir`, `pseudo_dir`,
      `restart_mode`, `tprnfor`, `tstress`, `etot_conv_thr`, `forc_conv_thr`,
      `nstep`, `disk_io`, `verbosity` — with validation of allowed values
- [x] **127.3.1.3** Implement &SYSTEM block generation: `ibrav` (0-14 Bravais
      lattice index) with celldm(1-6) or A/B/C/cosAB/cosAC/cosBC, `nat`, `ntyp`,
      `ecutwfc`, `ecutrho` (auto-set from ecutwfc × 4 for NC, ×8-12 for US/PAW),
      `occupations` (smearing/tetrahedra/fixed), `smearing`
      (gaussian/mv/mp/cold), `degauss`, `nspin` (1/2/4),
      `starting_magnetization`, `noncolin`, `lspinorb`, `nbnd`, `tot_charge`,
      `input_dft` (functional override), `vdw_corr` (grimme-d2/d3/ts/mbd),
      `hubbard_u` (DFT+U)
- [x] **127.3.1.4** Implement &ELECTRONS block generation: `conv_thr`,
      `mixing_mode`, `mixing_beta`, `mixing_ndim`, `diagonalization`
      (david/cg/ppcg), `electron_maxstep`, `startingpot`, `startingwfc`
- [x] **127.3.1.5** Implement &IONS block generation: `ion_dynamics`
      (bfgs/damp/verlet/langevin/...), `upscale`, `trust_radius_min`,
      `trust_radius_max`, `bfgs_ndim`
- [x] **127.3.1.6** Implement &CELL block generation: `cell_dynamics`
      (bfgs/damp-w/...), `press`, `press_conv_thr`, `cell_dofree`
      (all/x/y/z/xy/xz/yz/xyz/shape/volume/2Dxy/2Dshape)
- [x] **127.3.1.7** Implement ATOMIC_SPECIES card writer: element symbol, atomic
      mass, pseudopotential filename — with automatic pseudopotential selection
      from configured library
- [x] **127.3.1.8** Implement ATOMIC_POSITIONS card writer: support crystal
      (fractional), angstrom, bohr, alat, crystal_sg (space group Wyckoff
      positions) — with optional per-atom if_pos constraints (0/1 for each
      direction, QE equivalent of VASP selective dynamics)
- [x] **127.3.1.9** Implement K_POINTS card writer: automatic (nk1 nk2 nk3 sk1
      sk2 sk3), gamma, tpiba, crystal, tpiba_b (band structure), and crystal_b
      (band structure in crystal coords) — with auto-generation from target
      density
- [x] **127.3.1.10** Implement CELL_PARAMETERS card writer: when ibrav=0, write
      lattice vectors in angstrom, bohr, or alat units

#### 127.3.2 QE Presets & Pseudopotential Management

- [x] **127.3.2.1** Implement QE presets: `scf` (standard SCF), `relax` (ionic
      relaxation), `vc-relax` (full cell relaxation), `band_structure` (NSCF +
      bands.x), `dos` (NSCF + dos.x + projwfc.x), `phonon` (SCF → ph.x DFPT),
      `md_nvt` (Car-Parrinello or Born-Oppenheimer MD) — each preset sets all
      required namelists and cards with sensible defaults
- [x] **127.3.2.2** Implement pseudopotential library manager: support SSSP
      (Standard Solid-State Pseudopotentials) efficiency and precision
      libraries, PseudoDojo NC/US/PAW — for each element, store recommended
      pseudopotential filename, ecutwfc, ecutrho, and dual (rho/wfc ratio) —
      auto-select based on target accuracy
- [x] **127.3.2.3** Implement pseudopotential validation: verify UPF file header
      (PP_HEADER), extract Z_valence, mesh_size, functional, relativistic flag,
      is_ultrasoft/is_paw — ensure consistency with &SYSTEM settings

#### 127.3.3 QE Output Parsing

- [x] **127.3.3.1** Implement pw.x output parser: extract total energy (Ry),
      forces (Ry/Bohr), stress (kbar), eigenvalues, Fermi energy, magnetization,
      SCF convergence history, timing, number of k-points, number of plane
      waves, symmetry operations detected — handle both terminated and crashed
      runs
- [x] **127.3.3.2** Implement QE XML parser (data-file-schema.xml): parse QE
      6.x+ XML output — extract: input parameters, atomic structure (initial +
      final), band structure (eigenvalues at all k-points), total energy,
      forces, stress, timing, convergence info — this is the robust
      machine-readable output format
- [x] **127.3.3.3** Implement ph.x output parser: extract dynamical matrices at
      each q-point, phonon frequencies (cm⁻¹ and THz), Born effective charges
      (Z\*), macroscopic dielectric constant (ε∞), mode symmetry labels, Raman
      tensors (if calculated), IR intensities
- [x] **127.3.3.4** Implement matdyn.x output parser: parse phonon dispersion
      (frequencies along q-path) and phonon DOS from matdyn.x output — return
      `PhononBandStructure` and `PhononDOS` objects
- [x] **127.3.3.5** Implement pp.x output parser: read charge density,
      potential, ELF in cube format and XSF (XCrySDen) format — volumetric data
      on real-space grid for visualization

#### 127.3.4 Additional QE Tool Interfaces

- [x] **127.3.4.1** Implement bands.x interface: generate input for band
      structure post-processing (filband, lsym), parse output (bands.dat,
      bands.dat.gnu) for plotting
- [x] **127.3.4.2** Implement dos.x interface: generate input (fildos, Emin,
      Emax, DeltaE, ngauss, degauss), parse output DOS file — total DOS
- [x] **127.3.4.3** Implement projwfc.x interface: generate input (filpdos,
      Emin, Emax, DeltaE, ngauss, degauss), parse projected DOS output —
      per-atom, per-orbital PDOS files (_.pdos_atm#_\_wfc#\*)
- [x] **127.3.4.4** Implement epsilon.x interface: generate input for optical
      properties (interband transitions), parse dielectric function output (real
      and imaginary parts vs. energy)
- [x] **127.3.4.5** Implement hp.x interface: generate input for linear-response
      Hubbard U/V calculation (nq1-3, perturb_only_atom, compute_hp), parse
      output U and V values — for self-consistent DFT+U

---

### 127.4 ABINIT Interface (`@kalika/abinit-io`)

#### 127.4.1 Input Generation

- [x] **127.4.1.1** Implement ABINIT input file writer: generate ABINIT input
      format (variable = value lines, multi-dataset syntax with jdtset/ndtset
      and variable? suffixes) — handle all value types: scalars, arrays, 2D
      arrays (rprim, xred), string-valued variables
- [x] **127.4.1.2** Implement core variable generation: `acell`, `rprim`
      (lattice), `ntypat`, `znucl`, `natom`, `typat`, `xred`/`xcart`/`xangst`
      (coordinates), `ecut` (PW cutoff), `ngkpt` + `nshiftk` + `shiftk`
      (k-points), `tolvrs`/`toldfe`/`toldff` (convergence), `nstep`, `occopt` +
      `tsmear`, `nsppol`/`nspinor`/`nspden` (spin), `ixc` (XC functional),
      `pawecutdg` (PAW augmentation cutoff)
- [x] **127.4.1.3** Implement multi-dataset generation: create multi-dataset
      ABINIT inputs for chained calculations (e.g., dataset 1: SCF, dataset 2:
      NSCF band structure, dataset 3: DOS) — with proper
      `getden`/`irdden`/`irdwfk` chaining between datasets
- [x] **127.4.1.4** Implement ABINIT presets: `ground_state` (standard SCF),
      `relaxation` (ionmov=2/22, optcell=0/2), `band_structure` (iscf=-2,
      kptopt=-N for line mode), `dos` (prtdos=1/2/3), `dfpt_phonon` (rfphon=1,
      rfatpol, rfdir), `gw` (optdriver=3/4, gwcalctyp), `bse` (optdriver=99,
      bs_loband, bs_nstates)

#### 127.4.2 Output Parsing

- [x] **127.4.2.1** Implement ABINIT main output parser: extract total energy
      (Ha), forces (Ha/Bohr), stress (Ha/Bohr³), eigenvalues, Fermi energy,
      magnetization, SCF convergence, timing, symmetry info, warnings/errors —
      handling multi-dataset outputs
- [x] **127.4.2.2** Implement ABINIT NetCDF output reader: parse \_DEN.nc
      (density), \_WFK.nc (wavefunctions), \_DDB (derivative database for
      phonons), \_EIG.nc (eigenvalues) — using a NetCDF reading library
- [x] **127.4.2.3** Implement ABINIT DDB file parser: parse derivative database
      (dynamical matrices, Born effective charges, dielectric tensor) — for
      Anaddb post-processing (phonon band structure, thermodynamic properties,
      Grüneisen parameters)
- [x] **127.4.2.4** Implement ABINIT GW output parser: extract quasiparticle
      energies (E_KS, E_QP, Z renormalization factors), self-energy Σ(ω) on
      real/imaginary frequency axis, spectral function

---

### 127.5 FHI-aims Interface (`@kalika/fhi-aims-io`)

#### 127.5.1 Input Generation

- [x] **127.5.1.1** Implement geometry.in writer: write FHI-aims geometry file
      from KalikaStructure — `lattice_vector` lines (3 lines for periodic),
      `atom` or `atom_frac` lines (Cartesian or fractional), optional
      `velocity`, `initial_moment`, `constrain_relaxation` per atom
- [x] **127.5.1.2** Implement control.in writer: generate FHI-aims control file
      — `xc` (pbe/hse06/pbe0/lda/...), `relativistic` (atomic_zora/zora/none),
      `spin` (collinear/none), `k_grid` (n1 n2 n3), `sc_accuracy_rho`,
      `sc_accuracy_eev`, `sc_accuracy_etot`, `sc_accuracy_forces`,
      `relax_geometry` (bfgs/trm), `relax_unit_cell` (full/shape/none),
      `compute_forces`, `output band` lines, `output dos` settings — followed by
      species-specific basis set blocks
- [x] **127.5.1.3** Implement FHI-aims basis set selection: for each element,
      append the appropriate species_defaults block (light, intermediate, tight,
      really_tight) from the FHI-aims species_defaults directory — NAO (numeric
      atomic orbital) basis functions with radial functions, angular momentum
      channels, and basis set superposition
- [x] **127.5.1.4** Implement FHI-aims presets: `scf` (standard ground state),
      `relax` (geometry optimization with BFGS), `band_structure` (with output
      band directives along high-symmetry path), `dos` (with output dos
      settings), `hybrid` (HSE06/PBE0 with RI-V acceleration)

#### 127.5.2 Output Parsing

- [x] **127.5.2.1** Implement aims.out parser: extract total energy (eV),
      forces, stress, eigenvalues, Fermi energy, band gap, timing, SCF
      convergence history, Mulliken charges, Hirshfeld charges — handle periodic
      and molecular outputs
- [x] **127.5.2.2** Implement FHI-aims band structure parser: read band\*.out
      files (k-point, eigenvalues per band, occupation) — construct
      `BandStructure` object with k-path labels

---

### 127.6 Other DFT Code Interfaces (`@kalika/code-interfaces`)

#### 127.6.1 SIESTA Interface

- [x] **127.6.1.1** Implement SIESTA .fdf input writer: generate Flexible Data
      Format input — SystemName, SystemLabel, NumberOfAtoms, NumberOfSpecies,
      PAO.BasisSize (SZ/SZP/DZ/DZP/TZP), MeshCutoff, DM.MixingWeight,
      DM.Tolerance, MaxSCFIterations, MD.TypeOfRun, MD.NumCGsteps — plus block
      entries: %block LatticeVectors, %block AtomicCoordinatesAndAtomicSpecies,
      %block kgrid_Monkhorst_Pack, %block ChemicalSpeciesLabel
- [x] **127.6.1.2** Implement SIESTA output parser: parse .out file for total
      energy, forces, stress, Mulliken populations, eigenvalues, band structure
      (SystemLabel.bands), DOS (SystemLabel.DOS) — plus .XV (optimized
      coordinates), .ANI (trajectory)
- [x] **127.6.1.3** Implement SIESTA pseudopotential handling: .psf (Troullier-
      Martins) and .psml (PSML standard) format detection and validation

#### 127.6.2 CP2K Interface

- [x] **127.6.2.1** Implement CP2K .inp writer: generate CP2K input in
      hierarchical section format (&GLOBAL, &FORCE_EVAL{&DFT{&QS, &SCF, &XC,
      &MGRID, &POISSON}, &SUBSYS{&CELL, &COORD, &KIND}}, &MOTION{&GEO_OPT, &MD,
      &CELL_OPT}) — proper indentation and section nesting
- [x] **127.6.2.2** Implement CP2K output parser: extract total energy, forces,
      stress, SCF convergence, eigenvalues, Mulliken charges, band structure, MD
      trajectory — handle GPW (Gaussian and Plane Waves) and GAPW outputs
- [x] **127.6.2.3** Implement CP2K basis set and GTH pseudopotential selection:
      map elements to appropriate MOLOPT/ccGRB basis sets and GTH-PBE/GTH-BLYP
      pseudopotentials

#### 127.6.3 GPAW Interface

- [x] **127.6.3.1** Implement GPAW Python script generator: generate a Python
      script that imports `gpaw`, creates
      `GPAW(mode=PW(ecut), xc='PBE',     kpts=..., txt='output.txt')`, attaches
      to ASE Atoms, runs `calc.get_potential_energy()` — for SCF, relaxation,
      band structure, DOS workflows
- [x] **127.6.3.2** Implement GPAW output parser: parse gpaw .txt output and
      .gpw binary restart file — extract energy, forces, eigenvalues, DOS

#### 127.6.4 WIEN2k Interface

- [x] **127.6.4.1** Implement WIEN2k struct file writer: generate case.struct
      with lattice type, lattice parameters, atom positions (in internal
      coordinates), RMT values (muffin-tin radii), R0 (first radial mesh point),
      NPT (number of radial mesh points), ISPLIT — the master input file for
      all-electron LAPW calculations
- [x] **127.6.4.2** Implement WIEN2k case.in\* file generators: case.in1 (LAPW1:
      K-VECTORS, Emin/Emax), case.in2 (LAPW2: Fermi energy, partial charges),
      case.inm (MIXER: mixing parameters)
- [x] **127.6.4.3** Implement WIEN2k output parser: parse case.scf (SCF summary
      with energy, charge, moment per iteration), case.energy (eigenvalues),
      case.dos\* (DOS)

#### 127.6.5 Other Code Stubs

- [x] **127.6.5.1** Implement Elk elk.in writer: key blocks — tasks, avec
      (lattice), atoms (species + positions), ngridk, rgkmax, swidth — and
      output parser for TOTENERGY.OUT, EIGVAL.OUT, TDOS.OUT
- [x] **127.6.5.2** Implement CASTEP .cell/.param writer: .cell (lattice_cart,
      positions_frac, kpoint_mp_grid, symmetry_ops, species_pot), .param (task,
      xc_functional, cut_off_energy, elec_energy_tol, max_scf_cycles) — and
      .castep output parser
- [x] **127.6.5.3** Implement FLEUR inp.xml writer: generate XML-based input
      (lattice, atomGroups, xcFunctional, kPointMesh, cutoffs) — and output
      parser for out.xml
- [x] **127.6.5.4** Implement CRYSTAL .d12 writer: geometry (dimensionality,
      space group, lattice, atoms), basis set (all-electron or ECP), DFT
      parameters — and output parser for total energy, forces, band structure
- [x] **127.6.5.5** Implement Gaussian .gjf/.com writer: route section (#p
      method/basis), charge/multiplicity, geometry, additional keywords — and
      .log + .fchk output parser (energy, forces, frequencies, molecular
      orbitals)
- [x] **127.6.5.6** Implement ORCA .inp writer: method block (! DFT PBE
      def2-SVP), %pal (parallelism), %scf (convergence), coordinate block — and
      output parser for energy, forces, frequencies, NMR, EPR parameters

---

### 127.7 LAMMPS Interface (`@kalika/lammps-io`)

#### 127.7.1 Data File I/O

- [x] **127.7.1.1** Implement LAMMPS data file writer: generate atom data in
      full/atomic/charge/molecular atom styles — header (atom count, bond count,
      atom types, box bounds), Masses section, Atoms section (id, mol-id, type,
      charge, x, y, z), Velocities section, plus optional
      Bonds/Angles/Dihedrals/Impropers sections for molecular systems
- [x] **127.7.1.2** Implement LAMMPS data file reader: parse all sections of a
      LAMMPS data file — atoms, velocities, bonds, angles, masses, box
      dimensions (orthogonal and triclinic with tilt factors xy, xz, yz) —
      return KalikaStructure with topology information

#### 127.7.2 Input Script Generation

- [x] **127.7.2.1** Implement LAMMPS input script builder: fluent API for
      constructing LAMMPS input scripts — `setUnits('metal')`,
      `setAtomStyle('atomic')`, `setBoundary('p p p')`, `readData('data.lmp')`,
      `setPairStyle('eam/alloy')`, `setPairCoeff('* * pot.eam.alloy Al Cu')`,
      `addFix('1 all nvt temp 300 300 0.1')`, `addCompute(...)`,
      `setTimestep(0.001)`, `addDump(...)`, `setThermoStyle(...)`,
      `setThermoFreq(100)`, `run(10000)` — serialize to valid LAMMPS script
- [x] **127.7.2.2** Implement pair style configuration helpers: generate
      pair_style and pair_coeff commands for common potentials — `eam/alloy`
      (single file, all elements), `eam/fs` (Finnis-Sinclair), `tersoff` (Si, C,
      BN), `reaxff` (with control file), `lj/cut` (with per-type ε, σ), `buck`
      (Buckingham), `snap` (SNAP ML potential), `pace` (ACE ML potential),
      `meam` — with automatic unit conversion
- [x] **127.7.2.3** Implement fix command helpers: generate fix commands for
      standard ensembles — `nvt` (Nosé-Hoover thermostat), `npt` (barostat +
      thermostat with iso/aniso/tri options), `nve` (microcanonical), `langevin`
      (Langevin thermostat), `neb` (nudged elastic band), `shake` (bond
      constraints), `deform` (box deformation for strain), `wall/reflect`
      (walls)
- [x] **127.7.2.4** Implement compute command helpers: `pe/atom`, `stress/atom`,
      `rdf` (radial distribution function with cutoff and bins), `msd` (mean
      square displacement), `centro/atom` (centrosymmetry parameter), `cna/atom`
      (common neighbor analysis), `voronoi/atom`, `heat/flux` (for Green-Kubo
      thermal conductivity)
- [x] **127.7.2.5** Implement dump command helpers: `atom` (id, type, x, y, z),
      `custom` (configurable columns: id, type, x, y, z, vx, vy, vz, fx, fy, fz,
      c_pe, c_stress[1-6]), `cfg` (AtomEye), `netcdf` (NetCDF format) — with
      dump_modify (element names, sort, pad)
- [x] **127.7.2.6** Implement LAMMPS presets: `energy_minimization` (min_style
      cg, minimize etol ftol maxiter maxeval), `nvt_equilibration` (fix nvt +
      thermo + dump), `npt_equilibration` (fix npt with iso/aniso barostat),
      `tensile_test` (fix deform + compute stress/atom + dump),
      `thermal_conductivity` (NEMD or Green-Kubo setup), `neb` (neb command +
      replica setup)

#### 127.7.3 Output Parsing

- [x] **127.7.3.1** Implement LAMMPS log file parser: extract thermodynamic data
      columns (Step, Temp, Press, PotEng, KinEng, TotEng, Volume, Density,
      Lx/Ly/Lz, custom computes) from each run — handle multiple run blocks,
      minimization output, and LAMMPS-style column headers
- [x] **127.7.3.2** Implement LAMMPS dump file parser (Rust + WASM): read custom
      dump format (ITEM: TIMESTEP, ITEM: NUMBER OF ATOMS, ITEM: BOX BOUNDS,
      ITEM: ATOMS) — multi-frame trajectory support, lazy loading for large
      files, support both orthogonal and triclinic boxes. Rust for performance
      on multi-GB trajectory files
- [x] **127.7.3.3** Implement LAMMPS restart file reader: read binary restart
      format — extract atom positions, velocities, box dimensions, force field
      parameters — for analysis and restart continuation

#### 127.7.4 Potential File Management

- [x] **127.7.4.1** Implement LAMMPS potential file registry: manage local
      potential file library (EAM: .eam.alloy/.eam.fs, Tersoff: .tersoff,
      ReaxFF: ffield.reax, SNAP: .snapparam+.snapcoeff, ACE: .yace) — index by
      element combination, potential type, source publication
- [x] **127.7.4.2** Implement OpenKIM query interface: query the OpenKIM API
      (query.openkim.org) for available interatomic potentials by element
      combination, model type, property tested — retrieve KIM model IDs for use
      with `kim_interactions` command in LAMMPS

---

### 127.8 GROMACS Interface (`@kalika/gromacs-io`)

#### 127.8.1 File I/O

- [x] **127.8.1.1** Implement .gro coordinate file reader/writer: GROMACS format
      (title, atom count, residue number + name + atom name + atom number +
      coordinates in nm + optional velocities in nm/ps, box vectors) — convert
      to/from KalikaStructure
- [x] **127.8.1.2** Implement .top topology file writer: generate GROMACS
      topology — `[defaults]` (nbfunc, comb-rule, gen-pairs, fudgeLJ, fudgeQQ),
      `[atomtypes]`, `[moleculetype]`, `[atoms]` (nr, type, resnr, residue,
      atom, cgnr, charge, mass), `[bonds]`, `[pairs]`, `[angles]`, `[dihedrals]`
      (proper + improper), `[system]`, `[molecules]` — with #include for force
      field itp files
- [x] **127.8.1.3** Implement .mdp parameter file generator: generate run
      parameters for: `em` (energy minimization: integrator=steep/cg, emtol,
      emstep, nsteps), `nvt` (integrator=md, dt, nsteps, tcoupl= v-rescale,
      ref_t), `npt` (pcoupl=parrinello-rahman/berendsen, ref_p, tau_p),
      `production` (long MD run parameters) — with proper neighbor searching,
      cutoff, PME, constraint settings
- [x] **127.8.1.4** Implement .ndx index group file reader/writer:
      parse/generate GROMACS index files with named atom groups (System,
      Protein, DNA, Water, SOL, custom groups)

#### 127.8.2 Trajectory & Energy Parsing

- [x] **127.8.2.1** Implement .xtc trajectory reader (Rust + WASM): read
      compressed GROMACS trajectory format (XDR-encoded, lossy compression) —
      extract frame timestamps, box vectors, atom coordinates — lazy frame
      iteration for multi-GB trajectories. Rust for XDR decoding performance
- [x] **127.8.2.2** Implement .trr trajectory reader: read full-precision
      GROMACS trajectory (coordinates, velocities, forces, box, lambda) — XDR
      format parsing
- [x] **127.8.2.3** Implement .edr energy file reader: parse GROMACS portable
      energy format — extract all energy terms (Potential, Kinetic, Total,
      Temperature, Pressure, Volume, Density, individual LJ/Coulomb
      contributions) vs. time step
- [x] **127.8.2.4** Implement force field selection helper: map force field
      names (amber99sb-ildn, amber14sb, charmm36m, charmm27, oplsaa, gromos54a7)
      to appropriate GROMACS include paths and default settings

---

### 127.9 Phonopy / Phono3py Interface (`@kalika/phonopy-io`)

#### 127.9.1 Phonopy File I/O

- [x] **127.9.1.1** Implement phonopy.yaml reader/writer: parse the master
      Phonopy YAML configuration (supercell_matrix, primitive_matrix, atom
      types, positions, displacements) — including phonopy_disp.yaml (supercells
      with displacements)
- [x] **127.9.1.2** Implement FORCE_SETS file reader/writer: read/write Phonopy
      force sets format (number of atoms, number of displacements, for each:
      atom index, displacement vector, forces on all atoms) — the bridge between
      DFT force calculations and phonon analysis
- [x] **127.9.1.3** Implement BORN file reader/writer: read/write Born effective
      charges and dielectric tensor — format: dielectric tensor (3×3), then Born
      charges (3×3 per atom) — needed for LO-TO splitting correction in polar
      materials
- [x] **127.9.1.4** Implement band.yaml reader: parse phonon band structure
      output — q-points along path, frequencies (THz), eigenvectors (complex,
      per atom per mode), labels at high-symmetry points — return
      `PhononBandStructure` object
- [x] **127.9.1.5** Implement mesh.yaml reader: parse phonon DOS mesh output —
      q-points on mesh, frequencies, weights — for phonon density of states
      calculation
- [x] **127.9.1.6** Implement thermal_properties.yaml reader: parse
      thermodynamic properties — temperature array, free energy (kJ/mol),
      entropy (J/K/mol), heat capacity Cv (J/K/mol) — from the quasiharmonic
      phonon partition function

#### 127.9.2 Phonopy Workflow Integration

- [x] **127.9.2.1** Implement supercell displacement generator: given a
      KalikaStructure and supercell_matrix, generate all symmetrically distinct
      displaced supercells (reproducing Phonopy's displacement generation
      algorithm — apply symmetry to reduce displacement count) — output as array
      of KalikaStructure ready for DFT calculations
- [x] **127.9.2.2** Implement force constant calculator: given FORCE_SETS
      (displacements + DFT forces), compute harmonic force constants Φ(R) using
      the finite displacement method — matrix equation relating displacements to
      forces via crystal symmetry constraints
- [x] **127.9.2.3** Implement phonon property calculator: given force constants,
      compute phonon frequencies and eigenvectors at arbitrary q-points via
      dynamical matrix D(q) = Σ_R Φ(R) exp(iq·R) / √(M_i M_j) — including
      non-analytic correction for polar materials (Born charges + dielectric
      tensor → LO-TO splitting)
- [x] **127.9.2.4** Implement phonon DOS calculator: compute phonon density of
      states by sampling frequencies on a dense q-mesh with tetrahedron
      integration — total DOS and projected DOS (per atom contribution)
- [x] **127.9.2.5** Implement phonon thermodynamics: from phonon DOS, compute
      temperature-dependent free energy F(T), entropy S(T), heat capacity
      C_v(T), zero-point energy via the phonon partition function Z = Π_qν [2
      sinh(ℏω/2k_BT)]⁻¹

#### 127.9.3 Phono3py Interface

- [x] **127.9.3.1** Implement Phono3py FORCE_CONSTANTS_3RD reader/writer:
      read/write third-order force constants fc3(R1,R2) — the anharmonic force
      constants needed for lattice thermal conductivity
- [x] **127.9.3.2** Implement Phono3py thermal conductivity output parser: read
      kappa-m*.hdf5 or kappa-m*.dat — lattice thermal conductivity tensor κ_L(T)
      vs. temperature, mode-resolved κ contributions, phonon lifetimes τ(q,ν),
      group velocities v_g(q,ν), Grüneisen parameters

---

### 127.10 WANNIER90 Interface (`@kalika/wannier90-io`)

#### 127.10.1 Input Generation

- [x] **127.10.1.1** Implement wannier90.win writer: generate Wannier90 input
      file — `num_wann`, `num_bands`, `unit_cell_cart` (lattice), `atoms_frac`/
      `atoms_cart`, `mp_grid` (k-mesh), `begin kpoints` block,
      `begin     projections` block — with all major keywords:
      `dis_win_min/max`, `dis_froz_min/max` (disentanglement windows),
      `num_iter`, `conv_tol`, `conv_window`, `guiding_centres`, `write_hr`,
      `bands_plot`, `bands_num_points`, `begin kpoint_path` block
- [x] **127.10.1.2** Implement projection block generator: generate
      `begin     projections` from high-level specification — atom-centered
      projections (e.g., `Fe: d`, `O: p`, `C: sp3`), support all angular
      momentum channels (s, p, d, f), hybrid orbitals (sp, sp2, sp3, sp3d,
      sp3d2), custom radial functions, random projections — with automatic `l`,
      `mr`, `r` quantum number assignment
- [x] **127.10.1.3** Implement disentanglement window auto-setter: given
      eigenvalues from DFT, automatically determine optimal `dis_win_min`,
      `dis_win_max` (outer window encompassing target bands), `dis_froz_min`,
      `dis_froz_max` (frozen window around Fermi level or band gap) — heuristic
      based on band character and energy range

#### 127.10.2 File I/O

- [x] **127.10.2.1** Implement .amn file reader/writer: Wannier90 projection
      matrix A\_{mn}(k) — for each k-point, the num_bands × num_wann complex
      matrix of initial projections — format: header (num_bands, num_kpts,
      num_wann), then (band, wann, kpt, Re, Im) entries
- [x] **127.10.2.2** Implement .mmn file reader/writer: overlap matrix
      M\_{mn}(k,b) — for each k-point and each nearest-neighbor b-vector, the
      num_bands × num_bands complex overlap matrix — format: header, then (kpt,
      kpt+b, bx, by, bz) followed by matrix entries
- [x] **127.10.2.3** Implement .eig file reader/writer: eigenvalues ε\_{nk} —
      for each k-point and band, the DFT eigenvalue (eV) — simple three-column
      format: (band, kpt, eigenvalue)
- [x] **127.10.2.4** Implement .wout output parser: parse Wannier90 output —
      extract: initial/final spread (Ω, Ω_I, Ω_D, Ω_OD), Wannier function
      centers and spreads (per WF), convergence history, disentanglement
      convergence (if applicable), symmetry-adapted WF info

#### 127.10.3 Wannier Output & Applications

- [x] **127.10.3.1** Implement \_hr.dat reader: parse Wannier tight-binding
      Hamiltonian H(R) — degeneracy weights, then (Rx, Ry, Rz, i, j, Re_H, Im_H)
      entries — for Wannier-interpolated band structure and transport
- [x] **127.10.3.2** Implement Wannier-interpolated band structure calculator:
      given H(R) from \_hr.dat, compute eigenvalues at arbitrary k-points via
      H(k) = Σ_R H(R) exp(ik·R) — much denser k-mesh than DFT for smooth band
      structure and accurate Fermi surface
- [x] **127.10.3.3** Implement \_band.dat / \_band.kpt reader: parse Wannier90
      band structure output (k-point path coordinates + eigenvalues) for
      comparison with DFT bands
- [x] **127.10.3.4** Implement DFT→Wannier90 workflow connector: for VASP,
      generate INCAR tags (LWANNIER90=.TRUE. or manual .amn/.mmn via
      LWRITE_MMN_AMN); for QE, generate pw2wannier90.x input (outdir, prefix,
      seedname, write_amn, write_mmn, write_unk) — the glue between DFT and
      Wannier90
- [x] **127.10.3.5** Implement BoltzWann transport interface: generate BoltzWann
      input block in wannier90.win (boltzwann=.TRUE., boltz_calc_also_dos,
      boltz_mu_min/max, boltz_temp_min/max/step, boltz_relax_time) — parse
      BoltzWann output (σ, S, κ_e, PF vs. T, μ)

---

### 127.11 LOBSTER Interface (`@kalika/lobster-io`)

#### 127.11.1 Input Generation

- [x] **127.11.1.1** Implement lobsterin writer: generate LOBSTER input file —
      `COHPstartEnergy`, `COHPendEnergy`, `basisSet` (pbeVaspFit2015 /
      basisSetMappingFile), `gaussianSmearingWidth`, `userecommendedBasisSet`,
      `cohpGenerator` (from/to atom lists), `saveProjectionToFile`,
      `loadProjectionFromFile`, `basisfunctions` (per-element orbital
      specifications: e.g., `Fe 3d 4s 4p`)
- [x] **127.11.1.2** Implement automatic orbital selection: given a structure
      and list of atom pairs of interest, automatically select appropriate basis
      functions for LOBSTER analysis (valence orbitals, bonding-relevant
      orbitals) following LOBSTER recommendations per element

#### 127.11.2 Output Parsing

- [x] **127.11.2.1** Implement COHPCAR.lobster parser: read Crystal Orbital
      Hamilton Population data — energy grid, COHP(E) and integrated COHP
      (ICOHP) for each atom pair — per-spin if spin-polarized, per-orbital
      decomposition if requested. Return structured `CohpData` with atom pair
      labels, distances, and COHP/ICOHP arrays
- [x] **127.11.2.2** Implement COOPCAR.lobster parser: read Crystal Orbital
      Overlap Population — same format as COHPCAR but for overlap population —
      return `CoopData`
- [x] **127.11.2.3** Implement ICOHPLIST.lobster parser: extract integrated COHP
      values (bond strengths) at Fermi level for all atom pairs — sorted by
      ICOHP value, with distances, labels, and translation vectors
- [x] **127.11.2.4** Implement CHARGE.lobster parser: read Löwdin and Mulliken
      charges per atom — return structured charge data
- [x] **127.11.2.5** Implement GROSSPOP.lobster parser: read gross orbital
      populations per atom per orbital — for detailed electronic structure
      analysis
- [x] **127.11.2.6** Implement COBICAR.lobster parser: read Crystal Orbital Bond
      Index (COBI) data — the bond-order analogue of COHP/COOP — parse
      energy-resolved and integrated COBI per atom pair

---

### 127.12 BoltzTraP2 Interface (`@kalika/boltztrap-io`)

#### 127.12.1 Input Preparation

- [x] **127.12.1.1** Implement BoltzTraP2 input generator: from DFT band
      structure (eigenvalues on dense k-grid from VASP EIGENVAL or QE XML),
      generate BoltzTraP2 input — structure (lattice, atoms), eigenvalues
      ε\_{nk} at all irreducible k-points, k-point weights, Fermi energy — in
      BoltzTraP2's expected format (or via Python bridge to btp2 API)

#### 127.12.2 Output Parsing

- [x] **127.12.2.1** Implement BoltzTraP2 transport coefficient parser: extract
      σ/τ (electrical conductivity / relaxation time), S (Seebeck coefficient),
      κ_e/τ (electronic thermal conductivity / relaxation time), R_H (Hall
      coefficient) — all as functions of temperature T and chemical potential μ
      — return structured `TransportData` with interpolation capabilities
- [x] **127.12.2.2** Implement thermoelectric figure of merit calculator: given
      BoltzTraP2 σ/τ, S, κ_e/τ, plus lattice thermal conductivity κ_L from
      Phono3py, and an assumed relaxation time τ — compute power factor PF =
      S²σ, and ZT = S²σT/(κ_e + κ_L) as function of T and carrier concentration
      — the key materials screening metric for thermoelectrics

---

### 127.13 Ecosystem Compatibility (`@kalika/code-interfaces`)

#### 127.13.1 ASE Compatibility

- [x] **127.13.1.1** Implement ASE Atoms ↔ KalikaStructure bidirectional
      converter: map ASE Atoms (cell, positions, numbers, pbc, tags, momenta,
      initial_magnetic_moments, initial_charges, constraints) to/from
      KalikaStructure — preserve all site properties, handle FixAtoms and
      FixedLine/FixedPlane constraints ↔ selective dynamics
- [x] **127.13.1.2** Implement ASE Calculator adapter: wrap Kalika's code
      interfaces as an ASE-compatible Calculator (Python class via bridge) —
      implement `calculate()`, `get_potential_energy()`, `get_forces()`,
      `get_stress()` — enabling ASE workflows (optimizers, MD, NEB) to use
      Kalika-managed DFT codes as the energy/force engine
- [x] **127.13.1.3** Implement ASE trajectory reader/writer: read/write ASE's
      .traj format (Python pickle-based) and ASE's JSON trajectory format — for
      trajectory exchange between ASE and Kalika workflows
- [x] **127.13.1.4** Implement ASE database adapter: read/write ASE's SQLite
      database format (.db) — structure, energy, forces, stress, key-value
      pairs, data blobs — enabling Kalika to query and contribute to ASE
      databases

#### 127.13.2 pymatgen Compatibility

- [x] **127.13.2.1** Implement pymatgen Structure/Molecule ↔ KalikaStructure
      converter: map pymatgen Structure (lattice, species, frac_coords,
      site_properties) and Molecule (species, cart_coords) to/from
      KalikaStructure — handle oxidation states, spin, selective dynamics,
      Magmom objects
- [x] **127.13.2.2** Implement pymatgen DOS/BandStructure ↔ Kalika converter:
      convert pymatgen CompleteDos, Dos, BandStructureSymmLine objects to/from
      Kalika's DOS and BandStructure types — preserving orbital projections,
      spin channels, k-point labels
- [x] **127.13.2.3** Implement pymatgen PhaseDiagram compatibility: generate
      pymatgen-compatible `PDEntry` objects from Kalika calculation results
      (composition + energy) for phase stability analysis — or consume pymatgen
      PhaseDiagram results (stable entries, e_above_hull)
- [x] **127.13.2.4** Implement pymatgen InputSet/OutputParser adapter: bridge
      Kalika's VASP/QE input generators to pymatgen's VaspInputSet / QEInputSet
      interface, and Kalika's output parsers to pymatgen's Vasprun / Outcar
      classes — for code that expects pymatgen objects

#### 127.13.3 Workflow Framework Compatibility

- [x] **127.13.3.1** Implement AiiDA compatibility layer: convert Kalika
      WorkflowDAG to AiiDA WorkChain/CalcJob representation — map
      CalculationInput to AiiDA CalcJob inputs, CalculationOutput to AiiDA
      CalcJob outputs, WorkflowStep dependencies to AiiDA WorkChain logic —
      enable Kalika workflows to run on AiiDA infrastructure
- [x] **127.13.3.2** Implement FireWorks/Jobflow compatibility: convert Kalika
      WorkflowDAG to Jobflow Flow/Job representation (or FireWorks Workflow/
      Firework/FireTask) — mapping step dependencies to job dependencies, output
      passing to data stores — for submission to FireWorks LaunchPad
- [x] **127.13.3.3** Implement custodian error handler registry: register
      Kalika's VASP/QE error handlers in a format compatible with custodian's
      ErrorHandler interface — `check()` (detect error) and `correct()` (apply
      fix) methods — so Kalika workflows get custodian-level robustness
- [x] **127.13.3.4** Implement atomate2 workflow recipe matching: for key
      atomate2 workflows (StaticMaker, RelaxMaker, BandStructureMaker,
      ElasticMaker, PhononMaker, DefectMaker), create equivalent Kalika
      WorkflowDAG templates that produce compatible output schemas

#### 127.13.4 Additional Ecosystem Tools

- [x] **127.13.4.1** Implement AFLOW prototype library interface: query AFLOW
      prototype encyclopedia (aflow.org/prototype-encyclopedia/) — given a
      composition and space group, retrieve matching prototypes (Strukturbericht
      designation, Pearson symbol, Wyckoff positions) — generate KalikaStructure
      from prototype
- [x] **127.13.4.2** Implement Open Babel molecular format bridge: via Python
      bridge to openbabel, convert between molecular formats (SMILES, InChI,
      MOL, SDF, PDB, XYZ, CIF, VASP) — enabling Kalika to ingest molecular
      structures from any standard chemistry format
- [x] **127.13.4.3** Implement CIF symmetry operations handler: parse and apply
      CIF symmetry operations (space group generators in x,y,z notation) to
      generate all symmetry-equivalent positions from asymmetric unit —
      essential for building full unit cells from CIF data

---

### 127.14 Materials Databases (`@kalika/materials-databases`)

#### 127.14.1 Materials Project API

- [x] **127.14.1.1** Implement Materials Project REST client: authenticated HTTP
      client for MP API v2023+ (api.materialsproject.org) — API key management,
      rate limiting (configurable RPS), request retry with exponential backoff,
      pagination handling for large result sets
- [x] **127.14.1.2** Implement MP structure search: query materials by elements
      (contains/excludes), formula (exact/anonymous/reduced), crystal system,
      space group, number of sites, band gap range, energy above hull range,
      is_stable, magnetic ordering, has_props filter — return MaterialDoc list
      with material_id, formula, structure
- [x] **127.14.1.3** Implement MP property retrieval: fetch detailed properties
      for a material_id — total energy (per atom, per formula unit), formation
      energy, energy above hull, band gap (PBE, HSE, GW if available), DOS
      (total + projected), band structure, elastic tensor (C_ij, K_VRH, G_VRH,
      Poisson ratio), magnetic moment, dielectric constant, piezo tensor —
      return typed property objects
- [x] **127.14.1.4** Implement MP phase diagram client: fetch all entries in a
      chemical system (e.g., Li-Fe-O), construct `PhaseDiagram` from MP entries
      — compute stability (e_above_hull), decomposition products, equilibrium
      reaction, chemical potential ranges — for thermodynamic stability
      screening
- [x] **127.14.1.5** Implement MP thermo data access: fetch formation energies,
      decomposition energies, equilibrium reactions, energy above hull for all
      entries in a composition space — for large-scale stability analysis and
      Pourbaix diagram construction
- [x] **127.14.1.6** Implement MP task document access: fetch raw task documents
      (VASP calculation metadata) — INCAR settings used, k-point density,
      pseudopotentials, energy corrections applied (GGA mixing, anion
      corrections) — for reproducing or understanding MP calculations

#### 127.14.2 AFLOW API

- [x] **127.14.2.1** Implement AFLOW REST client: HTTP client for aflowlib.org
      REST API — construct AFLOW search URLs with filters (species, nspecies,
      Pearson, space_group, Egap, enthalpy_formation_atom), parse JSON
      responses, handle pagination (catalog, aurl)
- [x] **127.14.2.2** Implement AFLOW property retrieval: fetch structure
      (geometry, species, positions), formation enthalpy
      (enthalpy_formation_atom, enthalpy_formation_cell), band gap (Egap,
      Egap_type), elastic properties (ael_bulk_modulus_vrh,
      ael_shear_modulus_vrh, ael_poisson_ratio), magnetic properties — return
      typed objects
- [x] **127.14.2.3** Implement AFLOW prototype matching: given a
      KalikaStructure, query AFLOW prototype encyclopedia to identify the
      structure prototype (label, Strukturbericht, mineral name, Pearson symbol)
      — match by space group and Wyckoff positions

#### 127.14.3 JARVIS API

- [x] **127.14.3.1** Implement JARVIS REST client: HTTP client for
      jarvis.nist.gov API — query JARVIS-DFT, JARVIS-FF, JARVIS-ML datasets —
      filters by elements, formula, space group, dimensionality (3D/2D/1D), band
      gap range, formation energy range
- [x] **127.14.3.2** Implement JARVIS property retrieval: fetch DFT properties
      (optb88vdw formation energy, band gap, elastic constants, dielectric,
      piezoelectric, Born charges, phonon frequencies), 2D-specific properties
      (exfoliation energy, work function), ALIGNN ML predictions, solar cell
      efficiency metrics (SLME, SQ limit)
- [x] **127.14.3.3** Implement JARVIS 2D materials search: specialized query for
      2D materials database — filter by number of layers, exfoliation energy,
      band gap, magnetic ordering — return structures with layer-specific
      properties

#### 127.14.4 OQMD & NOMAD APIs

- [x] **127.14.4.1** Implement OQMD REST client: query oqmd.org/api/v1 — search
      by composition, filter by stability (delta_e), formation energy (delta_e),
      band gap, space group — fetch structure (sites, lattice) and calculated
      properties
- [x] **127.14.4.2** Implement NOMAD API client: query nomad-lab.eu API v1 —
      search by elements, formula, code (VASP/QE/etc.), upload date, dataset —
      fetch structures, energies, band structure, DOS from the FAIR (Findable
      Accessible Interoperable Reusable) materials data repository

#### 127.14.5 Crystallographic Databases

- [x] **127.14.5.1** Implement COD (Crystallography Open Database) client: query
      cod.iimcb.gov.pl REST API — search by formula, elements, cell parameters,
      space group, journal reference — download CIF files, parse to
      KalikaStructure — completely free and open access
- [x] **127.14.5.2** Implement ICSD query interface: generate ICSD-compatible
      search queries (composition, space group, Pearson, Wyckoff, cell
      parameters, structure type) — parse ICSD CIF exports — note: ICSD requires
      institutional subscription, so implement query/parse but not direct API
      access
- [x] **127.14.5.3** Implement Materials Cloud API client: query
      materialscloud.org — browse AiiDA-based datasets (curated entries with
      full provenance), fetch structures and properties — especially useful for
      2D materials, phonons, and GW datasets

#### 127.14.6 Standardized APIs

- [x] **127.14.6.1** Implement OPTIMADE client: query any OPTIMADE-compliant
      database (optimade.org) using standardized filter language —
      `filter=elements HAS "Li" AND nelements=3 AND nsites<20` — parse OPTIMADE
      JSON:API responses, extract structures (species, coordinates,
      lattice_vectors) — works with MP, AFLOW, OQMD, COD, NOMAD, MC3D, and 30+
      other databases through a single query interface
- [x] **127.14.6.2** Implement OPTIMADE provider registry: fetch and cache the
      list of OPTIMADE providers from providers.optimade.org — enable federated
      queries across all providers, aggregate results, de-duplicate by
      composition/space group
- [x] **127.14.6.3** Implement multi-database search aggregator: given search
      criteria (composition, property ranges), query multiple databases (MP,
      AFLOW, OQMD, JARVIS, NOMAD, COD) in parallel via OPTIMADE where available
      and native APIs otherwise — merge results, flag duplicates, compare
      reported properties across sources

#### 127.14.7 Molecular & Chemical Databases

- [x] **127.14.7.1** Implement PubChem REST client: query
      pubchem.ncbi.nlm.nih.gov PUG REST API — search by name, SMILES, InChI,
      molecular formula — retrieve 3D conformers, properties (molecular weight,
      charge, LogP, TPSA), CID — convert PubChem 3D structures to
      KalikaStructure (molecular, non-periodic)
- [x] **127.14.7.2** Implement Citrination/Citrine API client: query Citrine
      Informatics platform — search by material system, property (band gap,
      thermal conductivity, yield strength), data source — retrieve curated
      experimental and computational data — useful for ML training data

---

### 127.15 Workflow Engine (`@kalika/workflows`)

#### 127.15.1 DAG Execution Engine

- [x] **127.15.1.1** Implement workflow execution engine: execute a
      `WorkflowDAG` — topological traversal, parallel execution of independent
      steps, data passing between steps (output file mapping → input file
      placement), status tracking per step, event emission (step
      started/completed/ failed), timeout handling, overall workflow status
      aggregation
- [x] **127.15.1.2** Implement job submission abstraction: `JobSubmitter`
      interface with implementations for local execution (child process), SSH
      remote (paramiko-style), PBS/Torque (`qsub`), SLURM (`sbatch`), SGE
      (`qsub` with SGE flags), LSF (`bsub`) — each generating the appropriate
      job script with resource requests (nodes, cores, memory, walltime, queue)
- [x] **127.15.1.3** Implement job status polling: for each scheduler backend
      (local/PBS/SLURM/SGE/LSF), implement `getStatus(jobId): JobStatus` — map
      scheduler-specific states (SLURM: PENDING/RUNNING/COMPLETING/
      COMPLETED/FAILED/TIMEOUT/CANCELLED) to Kalika JobStatus enum — with
      configurable polling interval and exponential backoff
- [x] **127.15.1.4** Implement error recovery engine: when a workflow step
      fails, invoke the code-specific error detector (127.2.5.1 for VASP, etc.),
      apply automatic fixes if available, and restart the step — with
      configurable retry policy (max retries, fix escalation sequence) and
      dead-letter queue for unrecoverable failures

#### 127.15.2 Provenance & Results

- [x] **127.15.2.1** Implement provenance tracker: for each workflow execution,
      record the full provenance chain — input structure, calculation parameters
      (every INCAR/KPOINTS/POTCAR tag), code version, output files, parsed
      results, wall time, node/core count — stored as a DAG of ProvenanceNode
      objects with immutable content hashing
- [x] **127.15.2.2** Implement results database: store parsed calculation
      results (structure, energy, forces, band gap, DOS, elastic constants,
      etc.) in a queryable format — SQLite backend with typed columns, compound
      indices, and full-text search on notes/tags — for local result management
      and comparison
- [x] **127.15.2.3** Implement results comparison engine: given two or more
      calculation results for the same structure (e.g., PBE vs. HSE, or
      different k-point densities), compute differences in energy, forces, band
      gap, DOS overlap, elastic constants — for convergence testing and
      functional benchmarking
- [x] **127.15.2.4** Implement provenance serialization: export/import full
      provenance records as JSON/YAML — including structure snapshots, input
      parameters, output summaries, timing — for reproducibility documentation
      and sharing

#### 127.15.3 Built-in Workflow Templates

- [x] **127.15.3.1** Implement `relaxation_static` workflow: relax structure
      (ISIF=3, IBRION=2) → static calculation (ISMEAR=-5) → optional DOS/band
      structure — with automatic CONTCAR→POSCAR chaining, CHGCAR passing for
      NSCF, convergence checking between relax and static
- [x] **127.15.3.2** Implement `convergence_encut` workflow: run series of
      static calculations with increasing ENCUT (e.g., 200-800 eV in 50 eV
      steps) — extract energy vs. ENCUT, determine converged ENCUT (energy
      change < threshold, default 1 meV/atom)
- [x] **127.15.3.3** Implement `convergence_kpoints` workflow: run series of
      static calculations with increasing k-point density (e.g., 2×2×2 to
      12×12×12) — extract energy vs. k-points, determine converged mesh
- [x] **127.15.3.4** Implement `elastic_constants` workflow: apply 6 independent
      deformations (3 normal + 3 shear, with ±δ for central differences) to
      relaxed structure → static calculation for each → extract stress tensors →
      compute full 6×6 elastic tensor C_ij via stress-strain relation → derive
      bulk modulus K, shear modulus G (Voigt-Reuss-Hill averages), Young's
      modulus E, Poisson ratio ν
- [x] **127.15.3.5** Implement `phonon_supercell` workflow: generate supercell
      with Phonopy-compatible displacements → DFT force calculation for each
      displaced supercell → collect forces into FORCE_SETS → compute force
      constants → phonon band structure + DOS + thermodynamic properties — with
      automatic supercell size selection based on target accuracy
- [x] **127.15.3.6** Implement `defect_formation_energy` workflow: relax bulk
      supercell → create defect supercell (vacancy, substitution, interstitial)
      → relax defect supercell → compute raw defect formation energy E_f =
      E_defect - E_bulk + Σ n_i μ_i + q(E_VBM + E_Fermi) + E_correction — apply
      finite-size corrections (Freysoldt/Kumagai for charged defects)
- [x] **127.15.3.7** Implement `surface_energy` workflow: cleave slab from bulk
      (Miller indices hkl, slab thickness, vacuum thickness) → optimize slab →
      compute surface energy γ = (E_slab - n·E_bulk) / (2A) — with slab
      thickness convergence testing (increasing layers until γ converges)
- [x] **127.15.3.8** Implement `neb_barrier` workflow: interpolate images
      between initial and final structures (linear interpolation or IDPP — image
      dependent pair potential) → run CI-NEB calculation → extract minimum
      energy path and activation barrier — with automatic image count selection
- [x] **127.15.3.9** Implement `gw_band_gap` workflow: DFT relaxation → DFT
      static (dense k-mesh, many empty bands) → G0W0 calculation → extract
      quasiparticle band gap — with automatic NBANDS, ENCUTGW, NOMEGA
      convergence checks
- [x] **127.15.3.10** Implement `optical_bse` workflow: DFT → GW (quasiparticle
      energies) → BSE (Bethe-Salpeter equation for excitons) → absorption
      spectrum with excitonic effects — extract optical gap, exciton binding
      energy, dielectric function ε(ω)
- [x] **127.15.3.11** Implement `thermoelectric_zt` workflow: DFT relaxation →
      static (dense k-mesh) → Wannier90 interpolation → BoltzTraP2/BoltzWann
      transport (σ/τ, S, κ_e/τ) + phonon workflow (κ_L from Phono3py) → combine
      for ZT(T, n) map — the complete thermoelectric screening pipeline
- [x] **127.15.3.12** Implement `band_structure_hybrid` workflow: PBE relaxation
      → PBE static → HSE06 or PBE0 band structure (NSCF with hybrid functional
      on PBE charge density) — for accurate band gap prediction beyond semilocal
      DFT

#### 127.15.4 Workflow Utilities

- [x] **127.15.4.1** Implement workflow serialization: save/load WorkflowDAG
      definitions as YAML/JSON — including all step parameters, dependencies,
      output mappings, retry policies — for workflow sharing and version control
- [x] **127.15.4.2** Implement workflow dry-run mode: validate a WorkflowDAG
      without executing — check all input file dependencies are satisfied, all
      referenced codes are available, all parameter values are valid, estimated
      compute cost (core-hours) from similar past runs
- [x] **127.15.4.3** Implement workflow progress dashboard data: emit structured
      status updates for each workflow — overall progress (steps completed/
      total), per-step status (waiting/running/done/failed), estimated time
      remaining, resource utilization — for consumption by a UI layer
- [x] **127.15.4.4** Implement workflow template registry: register, discover,
      and instantiate built-in and user-defined workflow templates by name —
      `registry.get('elastic_constants').instantiate({ structure, code: 'vasp',     functional: 'PBE' })`
      — with parameter validation against template schema

---

### 127.16 Integration Tests & Cross-Code Validation

#### 127.16.1 Round-Trip Tests

- [x] **127.16.1.1** Implement VASP round-trip tests: generate INCAR/POSCAR/
      KPOINTS for Si diamond (FCC, 2 atoms) with each preset → write to string →
      parse back → verify all parameters preserved — for each preset (static,
      relaxation, band_structure, dos, dielectric, hybrid, phonon, elastic,
      aimd, soc)
- [x] **127.16.1.2** Implement QE round-trip tests: generate pw.x input for Si,
      GaAs, Fe (magnetic) with each preset → write → parse → verify all
      namelists and cards preserved — test ibrav=0 and ibrav>0 modes
- [x] **127.16.1.3** Implement LAMMPS round-trip tests: generate data file +
      input script for Cu FCC (EAM), SiO2 (Tersoff), polymer (full atom style) →
      write → parse → verify atom coordinates, box dimensions, pair coefficients
      preserved
- [x] **127.16.1.4** Implement structure format round-trip tests: convert Si
      diamond through all format converters (CIF → KalikaStructure → POSCAR →
      KalikaStructure → QE input → KalikaStructure → XYZ → KalikaStructure →
      CIF) — verify lattice parameters and fractional coordinates preserved
      within tolerance (1e-10)

#### 127.16.2 Cross-Code Consistency Tests

- [x] **127.16.2.1** Implement cross-code input consistency tests: for the same
      structure (Si diamond) and equivalent parameters (PBE, 500 eV, 8×8×8
      k-mesh), generate inputs for VASP, QE, ABINIT, FHI-aims — verify that
      equivalent physical parameters are set (same XC functional, same effective
      PW cutoff in Ry vs eV, same k-mesh)
- [x] **127.16.2.2** Implement unit conversion tests: verify all unit
      conversions against NIST reference values — eV↔Ha, Å↔Bohr, GPa↔kbar, etc.
      — with tolerances matching published CODATA uncertainties
- [x] **127.16.2.3** Implement database API response tests: mock HTTP responses
      from MP, AFLOW, JARVIS, OQMD APIs with real response payloads → parse →
      verify extracted structures and properties match known values (e.g., Si
      mp-149 band gap ≈ 0.6 eV PBE, ≈ 1.17 eV HSE)

#### 127.16.3 Output Parser Validation

- [x] **127.16.3.1** Implement VASP output parser tests: include fixture files
      (truncated real OUTCAR, vasprun.xml, DOSCAR, EIGENVAL, PROCAR for Si, Fe,
      GaAs) → parse → verify extracted energies, forces, band gap, DOS shape
      against reference values from the actual VASP runs
- [x] **127.16.3.2** Implement QE output parser tests: include fixture files
      (truncated pw.x output, XML data-file-schema for Si, MgO) → parse → verify
      energies (Ry), forces, eigenvalues against known values
- [x] **127.16.3.3** Implement Phonopy parser tests: include fixture files
      (band.yaml, mesh.yaml, FORCE_SETS for Si 2×2×2 supercell) → parse → verify
      phonon frequencies at Γ (3 acoustic = 0, 3 optical ≈ 15.5 THz for Si),
      thermodynamic properties at 300 K against published values
- [x] **127.16.3.4** Implement Wannier90 parser tests: include fixture files
      (.wout for Si 4-band sp3 Wannier functions, \_hr.dat) → parse → verify
      spread convergence, Wannier centers at bond-center positions, Hamiltonian
      matrix elements against reference
- [x] **127.16.3.5** Implement LOBSTER parser tests: include fixture COHPCAR for
      Fe-Fe bond → parse → verify ICOHP value, energy range, orbital
      decomposition against published LOBSTER tutorial values

#### 127.16.4 Workflow Template Tests

- [x] **127.16.4.1** Implement workflow DAG validation tests: construct each
      built-in workflow template → validate DAG (no cycles, all dependencies
      satisfied, all output mappings valid) → verify execution order layers —
      test with different codes (VASP, QE) and parameter variations
- [x] **127.16.4.2** Implement workflow serialization round-trip tests: for each
      built-in workflow template, serialize to YAML → deserialize → verify all
      steps, dependencies, and parameters preserved
- [x] **127.16.4.3** Implement error handler tests: simulate common VASP errors
      (inject ZBRENT, EDDDAV, ZPOTRF signatures into mock OUTCAR) → verify error
      detection triggers → verify fix suggestions are correct (POTIM reduction,
      ALGO change, etc.)
- [x] **127.16.4.4** Implement provenance tracking tests: execute a mock 3-step
      workflow → verify provenance DAG records all inputs, outputs, parameters,
      timing for each step — verify immutable content hashes match expected
      values

---

### 127.17 Documentation & Type Exports

#### 127.17.1 Public API Surface

- [x] **127.17.1.1** Implement barrel exports for `@kalika/code-interfaces`:
      export all core types (CalculationInput, CalculationOutput, CodeInterface,
      WorkflowStep, WorkflowDAG, JobStatus, KalikaStructure), all code-specific
      interfaces (VaspInterface, QeInterface, AbinitInterface, etc.), all
      converters (CIF, POSCAR, XYZ, PDB), unit conversion utilities, physical
      constants
- [x] **127.17.1.2** Implement barrel exports for `@kalika/vasp-io`: export
      INCAR writer/reader/validator/presets, POSCAR reader/writer, KPOINTS
      writer (automatic + line-mode), POTCAR manager, all output parsers
      (OUTCAR, vasprun.xml, DOSCAR, EIGENVAL, PROCAR, CHGCAR, etc.), error
      handlers, version compatibility layer
- [x] **127.17.1.3** Implement barrel exports for `@kalika/qe-io`: export pw.x
      input writer/presets, pseudopotential manager, all output parsers (pw.x,
      XML, ph.x, matdyn.x, pp.x), post-processing tool interfaces (bands.x,
      dos.x, projwfc.x, epsilon.x, hp.x)
- [x] **127.17.1.4** Implement barrel exports for `@kalika/lammps-io`: export
      data file reader/writer, input script builder, pair style helpers,
      fix/compute/dump helpers, presets, log parser, dump parser, potential
      registry, OpenKIM interface
- [x] **127.17.1.5** Implement barrel exports for `@kalika/materials-databases`:
      export all database clients (MP, AFLOW, JARVIS, OQMD, NOMAD, COD, ICSD,
      Materials Cloud, OPTIMADE, PubChem, Citrination), multi-database
      aggregator, OPTIMADE provider registry
- [x] **127.17.1.6** Implement barrel exports for `@kalika/workflows`: export
      WorkflowDAG, execution engine, job submitters (local/SLURM/PBS/SGE/ LSF),
      all built-in workflow templates, provenance tracker, results database,
      template registry
- [x] **127.17.1.7** Implement barrel exports for ancillary libraries:
      `@kalika/abinit-io`, `@kalika/fhi-aims-io`, `@kalika/phonopy-io`,
      `@kalika/wannier90-io`, `@kalika/lobster-io`, `@kalika/boltztrap-io`,
      `@kalika/gromacs-io` — each exporting all public types, generators,
      parsers, and utilities
